package cc.rengu.igas.bomp.core.realize.impl;

import cc.rengu.igas.bomp.common.constant.BompAppParamConstant;
import cc.rengu.igas.bomp.common.constant.TableNameConstant;
import cc.rengu.igas.bomp.common.dao.*;
import cc.rengu.igas.bomp.common.dao.impl.*;
import cc.rengu.igas.bomp.common.entity.*;
import cc.rengu.igas.bomp.common.enums.AuditStatusEnum;
import cc.rengu.igas.bomp.common.enums.BizTmpStatusEnum;
import cc.rengu.igas.bomp.common.enums.RespCodeEnum;
import cc.rengu.igas.bomp.common.util.InitParamUtil;
import cc.rengu.igas.bomp.core.realize.BspsPublicService;
import cc.rengu.igas.bomp.core.realize.MchntManageOperationService;
import cc.rengu.igas.bomp.facade.bean.BaseProdBean;
import cc.rengu.igas.bomp.facade.bean.MchntAuthCtrlInfoBean;
import cc.rengu.igas.bomp.facade.bean.MchntFeeInfoBean;
import cc.rengu.igas.bomp.facade.bean.MchntStageInfoBean;
import cc.rengu.igas.bomp.facade.request.MchntProdInfoManageRequest;
import cc.rengu.igas.share.core.model.DevBindInfo;
import cc.rengu.igas.share.core.model.MchntBindInfo;
import cc.rengu.oltp.service.common.constant.AppConfigConstant;
import cc.rengu.oltp.service.common.constant.AppParamConstant;
import cc.rengu.oltp.service.model.BizException;
import cc.rengu.oltp.utility.util.*;
import cc.rengu.utility.log.RgLog;
import cc.rengu.utility.log.RgLogger;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class MchntManageOperationServiceImpl implements MchntManageOperationService {

    private RgLogger rglog = RgLog.getLogger(this.getClass().getName());

    private static String ADD_OPR = "01";

    private static String MODIFY_OPR = "02";

    private static String DELETE_OPR = "04";


    @Override
    public void addBaseProdInfoByModifySingleSave(MchntProdInfoManageRequest request, MchntBaseInfo dbMchntBaseInfo,
                                                  String auditStatus, String createTime,
                                                  List<MchntProdInfo> totalMchntProdInfoList,
                                                  List<BizTmp> totalBizTmpList, BaseProdBean baseProdBean) throws Exception {
        //使用场景：新增通过后的修改单个产品信息（新增/修改/删除）
        //  新增审核通过/修改审核通过/修改审核拒绝  -》  修改
        //新增时：插入临时表  更新时：更新正式表状态，更新/插入临时表   删除：更新正式表审核状态，更新临时表
        rglog.debug("新增产品信息：{}", baseProdBean.getBaseProdCode());
        String instId = dbMchntBaseInfo.getInstId();
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        MchntProdInfo oldMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId,
                dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());

        if (null == oldMchntProdInfo) {
            //新增新的产品前先查询临时表是否有数据
            BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
            List<BizTmp> bizTmpProdList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_PROD_INFO);

            List<MchntProdInfo> prodInfoList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(bizTmpProdList)) {
                prodInfoList = bizTmpProdList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntProdInfo.class)).collect(Collectors.toList());
            }
            //场景：临时表保存了数据，但正式表没有
            Optional<MchntProdInfo> matchOptional = prodInfoList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).findFirst();
            if (matchOptional.isPresent()) {
                // 特殊场景 (1) 以前保存到临时表，但是没有提交审批的数据  （点击了单个产品保存，但提交审批时没有选择该产品）
                //(2) 修改正式商户--新增产品后（只有临时表存在数据），审核拒绝（修改临时表的状态为审核拒绝，标识为N），再次修改后进行提交
                MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, matchOptional.get(), auditStatus, createTime);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(),
                        JSONObject.toJSONString(mchntProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);

                // 其余数据都需先查临时表
                rglog.debug("特殊场景  保存到临时表，但是未提交审批/审批拒绝的数据");

                //费率
                List<BizTmp> bizTmpFeeList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_FEE_INFO);
                if (!CollectionUtils.isEmpty(bizTmpFeeList)) {
                    //场景：临时表保存了数据，但正式表没有，未上送新的费率数据，则使用旧数据
                    List<MchntFeeInfo> feeInfoList = bizTmpFeeList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntFeeInfo.class)).collect(Collectors.toList());
                    List<MchntFeeInfo> matchFeeList = feeInfoList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).collect(Collectors.toList());
                    if (!CollectionUtils.isEmpty(matchFeeList)) {
                        if (CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {
                            //未上送新的费率列表（内管：提交时只选择产品未单个进行），则使用临时表数据
                            for (MchntFeeInfo tmpFee : matchFeeList) {
                                //生效日期改为今天
                                tmpFee.setFeeEffectiveDate(DateUtil.getCurrentDate());
                                tmpFee.setFeeExpiryDate(BompAppParamConstant.DEFAULT_EXPIRY_DATE);
                                tmpFee.setRecordStatus(BompAppParamConstant.FLAG_Y);
                                tmpFee.setAuditStatus(auditStatus);
                                tmpFee.setLastOprId(request.getUserId());
                                tmpFee.setLastUpdateTime(createTime);
                                BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, tmpFee.getId(),
                                        JSONObject.toJSONString(tmpFee),
                                        TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizTmpFeeInfo);
                            }
                        } else {
                            //上送了费率信息，则使用新的费率数据，但id等信息沿用临时表数据
                            for (MchntFeeInfoBean modifyFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                                //判断临时表是否有费率类型一样的数据 feeType
                                List<MchntFeeInfo> matchItem = matchFeeList.stream().filter(item -> item.getFeeType().equals(modifyFeeInfoBean.getFeeType())).collect(Collectors.toList());
                                if (CollectionUtils.isEmpty(matchItem)) {
                                    //新增临时表数据
                                    MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), modifyFeeInfoBean, auditStatus, createTime);
                                    BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(),
                                            JSONObject.toJSONString(mchntFeeInfo),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizTmpFeeInfo);
                                } else {
                                    //有符合的数据，则沿用原数据的id
                                    MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, matchItem.get(0), modifyFeeInfoBean, auditStatus, createTime);
                                    BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(),
                                            JSONObject.toJSONString(mchntFeeInfo),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizTmpFeeInfo);
                                }
                            }
                        }
                    } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {
                        // 没有符合临时表费率数据
                        for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                            MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                            BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(),
                                    JSONObject.toJSONString(mchntFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmpFeeInfo);
                        }
                    }
                } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {
                    // 没有符合临时表费率数据
                    for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                        MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                        BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(),
                                JSONObject.toJSONString(mchntFeeInfo),
                                TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(bizTmpFeeInfo);
                    }
                }

                //权限
                List<BizTmp> bizTmpAuthList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_AUTH_CTRL);
                if (!CollectionUtils.isEmpty(bizTmpAuthList)) {
                    List<MchntAuthCtrl> authList = bizTmpAuthList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntAuthCtrl.class)).collect(Collectors.toList());
                    //场景：临时表保存了数据，但正式表没有
                    List<MchntAuthCtrl> matchAuthList = authList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBizProdCode())).collect(Collectors.toList());
                    if (!CollectionUtils.isEmpty(matchAuthList)) {
                        if (CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                            if (BompAppParamConstant.MCMP_CHANNEL.equals(request.getHeader().getChanlId())) {
                                List<MchntAuthCtrl> modifyBeAuditAuthList = matchAuthList.stream().filter(item -> AuditStatusEnum.MODIFY_BE_COMMIT_AUDIT.getAuditStatus().equals(item.getAuditStatus())).collect(Collectors.toList());
                                if (CollectionUtils.isEmpty(modifyBeAuditAuthList)) {
                                    //提交审批，未进产品页面进行保存，MCMP未上送权限，使用原来的数据
                                    for (MchntAuthCtrl tmpAuth : matchAuthList) {
                                        tmpAuth.setSupportFlag(BompAppParamConstant.FLAG_Y);
                                        tmpAuth.setAuditStatus(auditStatus);
                                        tmpAuth.setLastOprId(request.getUserId());
                                        tmpAuth.setLastUpdateTime(createTime);
                                        BizTmp bizAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, tmpAuth.getId(),
                                                JSONObject.toJSONString(tmpAuth),
                                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                        totalBizTmpList.add(bizAuthInfo);
                                    }
                                } else {
                                    //41-提交审批，则使用待审核的数据  opr_type12-提交审批时不上送数据，修改40状态的数据为41
                                    for (MchntAuthCtrl tmpAuth : modifyBeAuditAuthList) {
                                        tmpAuth.setAuditStatus(auditStatus);
                                        tmpAuth.setLastOprId(request.getUserId());
                                        tmpAuth.setLastUpdateTime(createTime);
                                        BizTmp bizAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, tmpAuth.getId(),
                                                JSONObject.toJSONString(tmpAuth),
                                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                        totalBizTmpList.add(bizAuthInfo);
                                    }
                                }
                            }
                        } else {
                            //上送了数据，则校验上送的数据是否已经在临时表存在
                            for (MchntAuthCtrlInfoBean modifyAuthCtrlBean : baseProdBean.getMchntAuthCtrlInfoBeanList()) {
                                //判断临时表是否有交易码txnNum，业务类型bizType 一样的数据
                                List<MchntAuthCtrl> matchItem = matchAuthList.stream().filter(item -> item.getTxnNum().equals(modifyAuthCtrlBean.getTxnNum()) && item.getBizType().equals(modifyAuthCtrlBean.getBizType())).collect(Collectors.toList());
                                if (CollectionUtils.isEmpty(matchItem)) {
                                    //无匹配数据，则新增临时表数据
                                    MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), modifyAuthCtrlBean, auditStatus, createTime);
                                    BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                            TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizMchntAuthCtrl);
                                } else {
                                    //有符合的数据，则沿用原数据的id
                                    MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreateModify(request, matchItem.get(0), modifyAuthCtrlBean, auditStatus, createTime);
                                    BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                            TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizMchntAuthCtrl);
                                }
                            }
                        }
                    } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                        for (MchntAuthCtrlInfoBean modifyAuthCtrlBean : baseProdBean.getMchntAuthCtrlInfoBeanList()) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), modifyAuthCtrlBean, auditStatus, createTime);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        }
                    }
                } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                    for (MchntAuthCtrlInfoBean modifyAuthCtrlBean : baseProdBean.getMchntAuthCtrlInfoBeanList()) {
                        MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), modifyAuthCtrlBean, auditStatus, createTime);
                        BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(bizMchntAuthCtrl);
                    }
                }

                //分期
                List<BizTmp> bizTmpStageList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_STAGE_INFO);
                if (!CollectionUtils.isEmpty(bizTmpStageList)) {
                    List<MchntStageInfo> stageList = bizTmpStageList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntStageInfo.class)).collect(Collectors.toList());
                    //场景：临时表保存了数据，但正式表没有
                    List<MchntStageInfo> matchStageList = stageList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).collect(Collectors.toList());
                    if (!CollectionUtils.isEmpty(matchStageList)) {
                        if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                            for (MchntStageInfoBean modifyStageBean : baseProdBean.getMchntStageInfoBeanList()) {
                                List<MchntStageInfo> matchItem;
                                if (!StringUtil.isEmptyOrNull(modifyStageBean.getId())) {
                                    matchItem = matchStageList.stream().filter(item -> item.getId().equals(modifyStageBean.getId())).collect(Collectors.toList());
                                } else {
                                    matchItem = matchStageList.stream().filter(item -> item.getProdStageCode().equals(modifyStageBean.getProdStageCode()) && item.getMchntStageNum() == modifyStageBean.getMchntStageNum()).collect(Collectors.toList());
                                }

                                if (!CollectionUtils.isEmpty(matchItem)) {
                                    MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, matchItem.get(0), modifyStageBean, auditStatus, createTime);
                                    BizTmp bizMchntStageInfo = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizMchntStageInfo);
                                } else {
                                    MchntStageInfo mchntStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), modifyStageBean, auditStatus, createTime);
                                    BizTmp bizMchntStageInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntStageInfo.getId(), JSONObject.toJSONString(mchntStageInfo),
                                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                    totalBizTmpList.add(bizMchntStageInfo);
                                }
                            }
                        } else {
                            for (MchntStageInfo tmpStage : matchStageList) {
                                tmpStage.setFeeEffectiveDate(DateUtil.getCurrentDate());
                                tmpStage.setFeeExpiryDate(BompAppParamConstant.DEFAULT_EXPIRY_DATE);
                                tmpStage.setRecordStatus(BompAppParamConstant.FLAG_Y);
                                tmpStage.setAuditStatus(auditStatus);
                                tmpStage.setLastOprId(request.getUserId());
                                tmpStage.setLastUpdateTime(createTime);
                                BizTmp bizTmpFeeInfo = initBizTmpByCreate(dbMchntBaseInfo, tmpStage.getId(),
                                        JSONObject.toJSONString(tmpStage),
                                        TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizTmpFeeInfo);
                            }
                        }

                    } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                        for (MchntStageInfoBean modifyStageInfoBean : baseProdBean.getMchntStageInfoBeanList()) {
                            MchntStageInfo mchntStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), modifyStageInfoBean, auditStatus, createTime);
                            BizTmp bizMchntStageInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntStageInfo.getId(), JSONObject.toJSONString(mchntStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntStageInfo);
                        }
                    }
                } else if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                    for (MchntStageInfoBean modifyStageInfoBean : baseProdBean.getMchntStageInfoBeanList()) {
                        MchntStageInfo mchntStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), modifyStageInfoBean, auditStatus, createTime);
                        BizTmp bizMchntStageInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntStageInfo.getId(), JSONObject.toJSONString(mchntStageInfo),
                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(bizMchntStageInfo);
                    }
                }
            } else {
                if ("12".equals(request.getOprType()) && BompAppParamConstant.MCMP_CHANNEL.equals(request.getHeader().getChanlId())) {
                    //修改审批提交新增，则取查询基础产品信息表，获取wechatChannelId 和 alipayChnanelId
                    MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreate(request, baseProdBean, auditStatus, createTime);
                    BaseProdInfoMapper baseProdInfoMapper = new BaseProdInfoMapperImpl();
                    BaseProdInfo baseProdInfo = baseProdInfoMapper.selectBaseProdInfoByPrimaryKey(instId, baseProdBean.getBaseProdCode());
                    if (StringUtil.isEmptyOrNull(request.getWechatChannelId())) {
                        mchntProdInfo.setWechatChannelId(baseProdInfo.getWechatChannelId());
                    }

                    if (StringUtil.isEmptyOrNull(request.getAlipayChannelId())) {
                        mchntProdInfo.setAlipayChannelId(baseProdInfo.getAlipayChannelId());
                    }
                    BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(), JSONObject.toJSONString(mchntProdInfo),
                            TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(bizTmpProdInfo);
                } else {
                    MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreate(request, baseProdBean, auditStatus, createTime);
                    BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(), JSONObject.toJSONString(mchntProdInfo),
                            TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(bizTmpProdInfo);
                }


                //Step2.费率信息  新增临时表费率信息  (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效，主键不会冲突)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {
//                    List<MchntFeeInfo> mchntFeeInfoList = baseProdBean.getMchntFeeInfoBeanList().stream()
//                            .map(item -> InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
//                            .collect(Collectors.toList());
                    List<MchntFeeInfo> mchntFeeInfoList = new ArrayList<>();
                    for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                        MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                        mchntFeeInfoList.add(mchntFeeInfo);
                    }

                    //费率业务临时信息
                    List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                            .map(item ->
                                    initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                            .collect(Collectors.toList());
                    totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
                } else if ("12".equals(request.getOprType()) && BompAppParamConstant.MCMP_CHANNEL.equals(request.getHeader().getChanlId())) {
                    //修改的时候，新增一个产品，直接提交审批，不经过单页面保存
                    ProdFeeInfoMapper prodFeeInfoMapper = new ProdFeeInfoMapperImpl();
                    List<ProdFeeInfo> feeInfoList = prodFeeInfoMapper.selectProdFeeInfoByBaseProdCode(instId, "00", baseProdBean.getBaseProdCode());
                    List<MchntFeeInfo> mchntFeeInfoList = feeInfoList.stream()
                            .map(item -> InitParamUtil.initMchntFeeInfoByProdFeeInfo(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                            .collect(Collectors.toList());
                    //费率业务临时信息
                    List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                            .map(item ->
                                    initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                            .collect(Collectors.toList());
                    totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
                }

                //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                    List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                        for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        }
                    }
                } else if ("12".equals(request.getOprType()) && BompAppParamConstant.MCMP_CHANNEL.equals(request.getHeader().getChanlId())) {
                    ProdAuthCtrlMapper prodAuthCtrlMapper = new ProdAuthCtrlMapperImpl();
                    List<ProdAuthCtrl> prodAuthCtrlList = prodAuthCtrlMapper.selectProdAuthCtrlInfoByBaseProdCode(instId, "00", baseProdBean.getBaseProdCode());
                    //修改的时候，新增一个产品，直接提交审批，不经过单页面保存
                    if (!CollectionUtils.isEmpty(prodAuthCtrlList)) {
                        prodAuthCtrlList = prodAuthCtrlList.stream().filter(item -> "01".equals(item.getStatus())).collect(Collectors.toList());
                        if (!CollectionUtils.isEmpty(prodAuthCtrlList)) {
                            //根据产品权限信息进行初始化商户权限信息
                            List<MchntAuthCtrl> mchntAuthCtrlList = prodAuthCtrlList.stream()
                                    .map(item -> InitParamUtil.initMchntAuthCtrlByProdAuthCtrl(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                    .collect(Collectors.toList());
                            //权限业务临时信息
                            List<BizTmp> mchntAuthTmpList = mchntAuthCtrlList.stream()
                                    .map(item ->
                                            initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                    .collect(Collectors.toList());
                            totalBizTmpList.addAll(mchntAuthTmpList);
                        }
                    }
                }

                //Step4.分期  新增临时表分期信息 (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                    List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                        List<MchntStageInfo> mchntStageInfoList = facadeStageInfoList.stream()
                                .map(item -> InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                .collect(Collectors.toList());
                        //分期临时信息
                        List<BizTmp> mchntStageBizTmp = mchntStageInfoList.stream()
                                .map(item ->
                                        initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                .collect(Collectors.toList());
                        totalBizTmpList.addAll(mchntStageBizTmp);
                    }
                } else if ("12".equals(request.getOprType()) && BompAppParamConstant.MCMP_CHANNEL.equals(request.getHeader().getChanlId())) {
                    //修改的时候，新增一个产品，直接提交审批，不经过单页面保存
                    ProdStageInfoMapper prodStageInfoMapper = new ProdStageInfoMapperImpl();
                    List<ProdStageInfo> prodStageInfoList = prodStageInfoMapper.selectProdStageInfoByProdType(instId, "00", baseProdBean.getBaseProdCode());
                    if (!CollectionUtils.isEmpty(prodStageInfoList)) {
                        //根据标准分期信息进行初始化商户权限信息
                        prodStageInfoList = prodStageInfoList.stream().filter(item -> "01".equals(item.getStageStatus())).collect(Collectors.toList());
                        if (!CollectionUtils.isEmpty(prodStageInfoList)) {
                            List<MchntStageInfo> mchntStageInfoList = prodStageInfoList.stream()
                                    .map(item -> InitParamUtil.initMchntStageInfoByProdStageInfo(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                    .collect(Collectors.toList());
                            //分期业务临时信息
                            List<BizTmp> mchntStageTmpList = mchntStageInfoList.stream()
                                    .map(item ->
                                            initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                    .collect(Collectors.toList());
                            totalBizTmpList.addAll(mchntStageTmpList);
                        }
                    }
                }

            }
        } else {
            //Step1. 将原来失效的数据设置为 修改待审核
            oldMchntProdInfo.setAuditStatus(auditStatus);
            oldMchntProdInfo.setLastOprId(request.getUserId());
            oldMchntProdInfo.setLastUpdateTime(createTime);
            totalMchntProdInfoList.add(oldMchntProdInfo);

            //设置临时表为生效
            MchntProdInfo afterProdInfo = new MchntProdInfo();
            BeanUtil.beanCopy(oldMchntProdInfo, afterProdInfo);
            afterProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, oldMchntProdInfo, auditStatus, createTime);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, afterProdInfo.getId(), JSONObject.toJSONString(afterProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);


            //Step2.费率信息  新增临时表费率信息  (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效，主键不会冲突)
            if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {

                List<MchntFeeInfo> mchntFeeInfoList = new ArrayList<>();
                for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                    MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                    mchntFeeInfoList.add(mchntFeeInfo);
                }
                //费率业务临时信息
                List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                        .map(item ->
                                initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                        TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                        .collect(Collectors.toList());
                totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
            } else {
                ProdFeeInfoMapper prodFeeInfoMapper = new ProdFeeInfoMapperImpl();
                //使用默认基础产品信息
                List<ProdFeeInfo> feeInfoList = prodFeeInfoMapper.selectProdFeeInfoByBaseProdCode(instId, "00", baseProdBean.getBaseProdCode());

                if (!CollectionUtils.isEmpty(feeInfoList)) {

                    //根据标准产品费率信息进行初始化商户费率信息
                    feeInfoList = feeInfoList.stream().filter(item -> "01".equals(item.getFeeStatus())).collect(Collectors.toList());

                    if (!CollectionUtils.isEmpty(feeInfoList)) {
                        List<MchntFeeInfo> mchntFeeInfoList = feeInfoList.stream()
                                .map(item -> InitParamUtil.initMchntFeeInfoByProdFeeInfoModify(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                .collect(Collectors.toList());

                        //费率业务临时信息
                        List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                                .map(item ->
                                        initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                .collect(Collectors.toList());
                        totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
                    }
                }

            }

            //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
            if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                    //判断是否原来就有数据
                    MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                    for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                        //考虑原有数据是失效， 当前则为重启，则使用原有数据 （产品/权限）
                        MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());
                        if (null == oldMchntAuthCtrl) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        } else {
                            //将原有失效数据还未修改待审核
                            oldMchntAuthCtrl.setAuditStatus(auditStatus);
                            oldMchntAuthCtrl.setLastOprId(request.getUserId());
                            oldMchntAuthCtrl.setLastUpdateTime(createTime);

                            //设置临时表为生效
                            MchntAuthCtrl afterAuthCtrl = new MchntAuthCtrl();
                            BeanUtil.beanCopy(oldMchntAuthCtrl, afterAuthCtrl);
                            afterAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                            BizTmp bizTmpAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, afterAuthCtrl.getId(), JSONObject.toJSONString(afterAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmpAuthInfo);
                        }
                    }
                }
            } else {
                ProdAuthCtrlMapper prodAuthCtrlMapper = new ProdAuthCtrlMapperImpl();
                List<ProdAuthCtrl> prodAuthCtrlList = prodAuthCtrlMapper.selectProdAuthCtrlInfoByBaseProdCode(instId, "00", baseProdBean.getBaseProdCode());
                if (!CollectionUtils.isEmpty(prodAuthCtrlList)) {
                    prodAuthCtrlList = prodAuthCtrlList.stream().filter(item -> "01".equals(item.getStatus())).collect(Collectors.toList());
                    if (!CollectionUtils.isEmpty(prodAuthCtrlList)) {
                        MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                        for (ProdAuthCtrl prodAuthCtrl : prodAuthCtrlList) {
                            //考虑原有数据是失效， 当前则为重启，则使用原有数据 （产品/权限）
                            MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", prodAuthCtrl.getTxnNum(), prodAuthCtrl.getBizType());
                            if (null == oldMchntAuthCtrl) {
                                MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByProdAuthCtrl(request, baseProdBean.getBaseProdCode(), prodAuthCtrl, auditStatus, createTime);
                                BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                        TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizMchntAuthCtrl);
                            } else {
                                //将原有失效数据还未修改待审核
                                oldMchntAuthCtrl.setAuditStatus(auditStatus);
                                oldMchntAuthCtrl.setLastOprId(request.getUserId());
                                oldMchntAuthCtrl.setLastUpdateTime(createTime);

                                //设置临时表为生效
                                MchntAuthCtrl afterAuthCtrl = new MchntAuthCtrl();
                                BeanUtil.beanCopy(oldMchntAuthCtrl, afterAuthCtrl);
                                afterAuthCtrl.setSupportFlag(BompAppParamConstant.FLAG_Y);
                                BizTmp bizTmpAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, afterAuthCtrl.getId(), JSONObject.toJSONString(afterAuthCtrl),
                                        TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizTmpAuthInfo);
                            }
                        }
                    }
                }
            }

            //Step4.分期  新增临时表分期信息 (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效)
            if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
                if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                    List<MchntStageInfo> mchntStageInfoList = facadeStageInfoList.stream()
                            .map(item -> InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                            .collect(Collectors.toList());
                    //分期临时信息
                    List<BizTmp> mchntStageBizTmp = mchntStageInfoList.stream()
                            .map(item ->
                                    initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                            .collect(Collectors.toList());
                    totalBizTmpList.addAll(mchntStageBizTmp);
                }
            } else {
                ProdStageInfoMapper prodStageInfoMapper = new ProdStageInfoMapperImpl();
                List<ProdStageInfo> prodStageInfoList = prodStageInfoMapper.selectProdStageInfoByProdType(instId, "00", baseProdBean.getBaseProdCode());

                if (!CollectionUtils.isEmpty(prodStageInfoList)) {
                    //根据标准产品权限信息进行初始化商户权限信息
                    prodStageInfoList = prodStageInfoList.stream().filter(item -> "01".equals(item.getStageStatus())).collect(Collectors.toList());
                    if (!CollectionUtils.isEmpty(prodStageInfoList)) {
                        List<MchntStageInfo> mchntStageInfoList = prodStageInfoList.stream()
                                .map(item -> InitParamUtil.initMchntStageInfoByProdStageInfoModify(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                .collect(Collectors.toList());
                        //费率业务临时信息
                        List<BizTmp> mchntStageTmpList = mchntStageInfoList.stream()
                                .map(item ->
                                        initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                .collect(Collectors.toList());
                        totalBizTmpList.addAll(mchntStageTmpList);
                    }
                }
            }
        }
    }

    @Override
    public void modifyBaseProdInfoByModifySingleSave(MchntProdInfoManageRequest request,
                                                     MchntBaseInfo dbMchntBaseInfo,
                                                     String auditStatus, String createTime,
                                                     List<MchntProdInfo> totalMchntProdInfoList,
                                                     List<MchntFeeInfo> totalFeeInfoList,
                                                     List<MchntStageInfo> totalStageInfoList,
                                                     List<MchntAuthCtrl> totalAuthCtrlList,
                                                     List<BizTmp> totalBizTmpList,
                                                     BaseProdBean baseProdBean) throws Exception {
        //使用场景：新增通过后的修改单个产品信息（新增/修改/删除）
        //  新增审核通过/修改审核通过/修改审核拒绝  -》  修改
        //新增时：插入临时表  更新时：更新正式表状态，更新/插入临时表   删除：更新正式表审核状态，更新临时表
        String instId = dbMchntBaseInfo.getInstId();
        //修改产品信息
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        MchntProdInfo dbMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());
        if (null == dbMchntProdInfo) {
            rglog.error("数据库正式表无此产品信息！查询临时表，instId:{},mchntNo:{},audisStatus:{}", dbMchntBaseInfo.getInstId(), dbMchntBaseInfo.getMchntNo(), dbMchntBaseInfo.getAuditStatus());
            BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
            List<BizTmp> prodTmpList = bizTmpMapper.selectBizTmpByMchntNo(dbMchntBaseInfo.getInstId(), dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_PROD_INFO);
            if (!CollectionUtils.isEmpty(prodTmpList)) {
                List<MchntProdInfo> bizMchntProdList = prodTmpList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntProdInfo.class)).collect(Collectors.toList());
                List<MchntProdInfo> targetProdList = bizMchntProdList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(targetProdList)) {
                    throw new BizException(RespCodeEnum.MCHNT_INFO_NOT_FOUND.getRespCode(), RespCodeEnum.MCHNT_INFO_NOT_FOUND.getRespDesc());
                }

                MchntProdInfo targetProdInfo = targetProdList.get(0);
                //修改后的商户产品
                MchntProdInfo modifyProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, targetProdInfo, auditStatus, createTime);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, targetProdInfo.getId(), JSONObject.toJSONString(modifyProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);
            } else {
                rglog.error("数据库临时表无此产品信息！，instId:{},mchntNo:{},audisStatus:{}", dbMchntBaseInfo.getInstId(), dbMchntBaseInfo.getMchntNo(), dbMchntBaseInfo.getAuditStatus());
                throw new BizException(RespCodeEnum.MCHNT_INFO_NOT_FOUND.getRespCode(), RespCodeEnum.MCHNT_INFO_NOT_FOUND.getRespDesc());
            }
        } else {
            dbMchntProdInfo.setAuditStatus(auditStatus);
            dbMchntProdInfo.setLastUpdateTime(createTime);
            dbMchntProdInfo.setLastOprId(request.getUserId());
            totalMchntProdInfoList.add(dbMchntProdInfo);

            //修改后的商户产品
            MchntProdInfo modifyProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, dbMchntProdInfo, auditStatus, createTime);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, dbMchntProdInfo.getId(), JSONObject.toJSONString(modifyProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);
        }


        List<MchntFeeInfoBean> facadeFeeInfoList = baseProdBean.getMchntFeeInfoBeanList();
        //费率信息 将上传的信息进行修改
        if (!CollectionUtils.isEmpty(facadeFeeInfoList)) {
            MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
            for (MchntFeeInfoBean mchntFeeInfoBean : facadeFeeInfoList) {
                if (ADD_OPR.equals(mchntFeeInfoBean.getOprType())) {
                    //新增数据
                    MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                    //费率业务临时信息
                    BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(bizTmp);
                } else if (MODIFY_OPR.equals(mchntFeeInfoBean.getOprType())) {
                    //修改时，先查正式表数据，后修改临时表数据，新增新费率的临时表数据
                    MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                    if (null != dbMchntFeeInfo) {
                        BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                        BizTmp currentBizTmp = bizTmpMapper.selectBizTmpByRealId(instId, mchntFeeInfoBean.getId());
                        MchntFeeInfo bizFee = JSON.parseObject(InitParamUtil.getJsonString(currentBizTmp), MchntFeeInfo.class);
                        if ((DateUtil.compareDate(dbMchntFeeInfo.getFeeExpiryDate(), DateUtil.getCurrentDate()) <= 0)
                                || (DateUtil.compareDate(bizFee.getFeeExpiryDate(), DateUtil.getCurrentDate()) <= 0)) {
                            rglog.error("当前修改的费率的失效日期<{}> 小于等于当前日期<{}>，不允许再次修改", dbMchntFeeInfo.getFeeExpiryDate(), DateUtil.getCurrentDate());
                            throw new BizException(RespCodeEnum.ILLEGAL_OPERATION.getRespCode(), RespCodeEnum.ILLEGAL_OPERATION.getRespDesc());
                        }

                        if (DateUtil.compareDate(dbMchntFeeInfo.getFeeEffectiveDate(), DateUtil.getCurrentDate()) > 0) {
                            //生效日期在明天，则直接改临时表费率信息，无需新增临时表（修改明天生效的数据） [场景：该条数据今天修改了多次]
                            dbMchntFeeInfo.setAuditStatus(auditStatus);
                            dbMchntFeeInfo.setLastUpdateTime(createTime);
                            dbMchntFeeInfo.setLastOprId(request.getUserId());
                            totalFeeInfoList.add(dbMchntFeeInfo);

                            MchntFeeInfo newFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, dbMchntFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            InitParamUtil.initBizTempData(currentBizTmp, JSONObject.toJSONString(newFeeInfo));
                            currentBizTmp.setAuditStatus(auditStatus);
                            currentBizTmp.setLastUpdateTime(createTime);
                            currentBizTmp.setLastOprId(request.getUserId());
                            totalBizTmpList.add(currentBizTmp);
                        } else {
                            dbMchntFeeInfo.setAuditStatus(auditStatus);
                            dbMchntFeeInfo.setLastUpdateTime(createTime);
                            dbMchntFeeInfo.setLastOprId(request.getUserId());
                            totalFeeInfoList.add(dbMchntFeeInfo);

                            //临时表 中的正式数据改为失效 失效日期为当天
                            MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                            BeanUtil.beanCopy(dbMchntFeeInfo, afterDbMchntFeeInfo);
                            afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                            dbFeeBizTmp.setBizOpr("D");
                            totalBizTmpList.add(dbFeeBizTmp);

                            //新增一条修改后的数据
                            MchntFeeInfo newFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                            BizTmp newFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, newFeeInfo.getId(), JSONObject.toJSONString(newFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            newFeeBizTmp.setRemark1(dbFeeBizTmp.getRealId());
                            //新数据改为启用 审核通过是如果为启用，新增正式表数据生效日期改为下一天
                            newFeeBizTmp.setBizOpr("E");
                            totalBizTmpList.add(newFeeBizTmp);
                        }

                    } else {
                        //修改临时表的数据
                        BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                        BizTmp tmpFee = bizTmpMapper.selectBizTmpByRealId(instId, mchntFeeInfoBean.getId());
                        if (null != tmpFee) {
                            String json = InitParamUtil.getJsonString(tmpFee);
                            MchntFeeInfo tmpFeeInfo = JSON.parseObject(json, MchntFeeInfo.class);
                            MchntFeeInfo newFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, tmpFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            //新数据改为启用 审核通过是如果为启用，新增正式表数据生效日期改为下一天
                            tmpFee.setBizOpr("E");
                            tmpFee.setLastOprId(request.getUserId());
                            tmpFee.setLastUpdateTime(createTime);
                            InitParamUtil.initBizTempData(tmpFee, JSONObject.toJSONString(newFeeInfo));
                            totalBizTmpList.add(tmpFee);
                        }
                    }
                } else if (DELETE_OPR.equals(mchntFeeInfoBean.getOprType())) {
                    //删除
                    MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                    if (null != dbMchntFeeInfo) {
                        dbMchntFeeInfo.setAuditStatus(auditStatus);
                        dbMchntFeeInfo.setLastUpdateTime(createTime);
                        dbMchntFeeInfo.setLastOprId(request.getUserId());
                        totalFeeInfoList.add(dbMchntFeeInfo);

                        //临时表改为失效
                        MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                        BeanUtil.beanCopy(dbMchntFeeInfo, afterDbMchntFeeInfo);
                        //将数据库中的费率设置为失效，失效日期为当天
                        afterDbMchntFeeInfo.setRecordStatus(AppParamConstant.NO);
                        afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                        BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                                TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                        dbFeeBizTmp.setBizOpr("D");
                        totalBizTmpList.add(dbFeeBizTmp);
                    }
                }
            }
        }

        //分期数据
        List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
        if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
            MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
            for (MchntStageInfoBean mchntStageInfoBean : facadeStageInfoList) {
                if (ADD_OPR.equals(mchntStageInfoBean.getOprType())) {
                    MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntStageInfoBean, auditStatus, createTime);
                    //费率业务临时信息
                    BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(bizTmp);
                } else if (MODIFY_OPR.equals(mchntStageInfoBean.getOprType())) {
                    MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                    if (null != dbStageInfo) {

                        BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                        BizTmp currentBizTmp = bizTmpMapper.selectBizTmpByRealId(instId, mchntStageInfoBean.getId());
                        MchntStageInfo bizStage = JSON.parseObject(InitParamUtil.getJsonString(currentBizTmp), MchntStageInfo.class);

                        if ((DateUtil.compareDate(dbStageInfo.getFeeExpiryDate(), DateUtil.getCurrentDate()) <= 0)
                                || (DateUtil.compareDate(bizStage.getFeeExpiryDate(), DateUtil.getCurrentDate()) <= 0)) {
                            rglog.error("当前修改的费率的失效日期<{}> 小于等于当前日期<{}>，不允许再次修改", dbStageInfo.getFeeExpiryDate(), DateUtil.getCurrentDate());
                            throw new BizException(RespCodeEnum.ILLEGAL_OPERATION.getRespCode(), RespCodeEnum.ILLEGAL_OPERATION.getRespDesc());
                        }

                        if (AppParamConstant.YES.equals(dbStageInfo.getRecordStatus())) {
                            dbStageInfo.setAuditStatus(auditStatus);
                            dbStageInfo.setLastUpdateTime(createTime);
                            dbStageInfo.setLastOprId(request.getUserId());
                            totalStageInfoList.add(dbStageInfo);

                            //临时表 中的正式数据改为失效 失效日期为明天
                            MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                            BeanUtil.beanCopy(dbStageInfo, afterDbMchntStageInfo);
                            //原key不允许修改
                            afterDbMchntStageInfo.setStagePrimaryKey(dbStageInfo.getStagePrimaryKey());
                            afterDbMchntStageInfo.setRecordStatus(mchntStageInfoBean.getRecordStatus());
                            if (!AppParamConstant.NO.equals(mchntStageInfoBean.getRecordStatus())) {
                                afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            }

                            BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                            if (AppParamConstant.YES.equals(mchntStageInfoBean.getRecordStatus())) {
                                dbStageBizTmp.setBizOpr("D");
                            }
                            totalBizTmpList.add(dbStageBizTmp);
                        } else {
                            //停用改启用 失效日期截止到今天
                            dbStageInfo.setAuditStatus(auditStatus);
                            dbStageInfo.setLastUpdateTime(createTime);
                            dbStageInfo.setLastOprId(request.getUserId());
                            totalStageInfoList.add(dbStageInfo);

                            //停用数据启用 日期截止到当天
                            //临时表 中的正式数据改为失效 失效日期为明天
                            MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                            BeanUtil.beanCopy(dbStageInfo, afterDbMchntStageInfo);
                            //原key不允许修改
                            afterDbMchntStageInfo.setStagePrimaryKey(dbStageInfo.getStagePrimaryKey());
                            //recordStatus 不修改，新增一条新的数据 (该条数据依旧是失效，新增一条数据生效日期是明天)
//                            afterDbMchntStageInfo.setRecordStatus(mchntStageInfoBean.getRecordStatus());
                            if (!AppParamConstant.NO.equals(mchntStageInfoBean.getRecordStatus())) {
                                afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            }

                            BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                            if (AppParamConstant.YES.equals(mchntStageInfoBean.getRecordStatus())) {
                                dbStageBizTmp.setBizOpr("D");
                            }
                            totalBizTmpList.add(dbStageBizTmp);
                        }

                        if (!AppParamConstant.NO.equals(mchntStageInfoBean.getRecordStatus())) {
                            //新增一条修改后的数据
                            MchntStageInfo newStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntStageInfoBean, auditStatus, createTime);
                            BizTmp newStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, newStageInfo.getId(), JSONObject.toJSONString(newStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            newStageBizTmp.setRemark1(dbStageInfo.getId());

                            //新数据改为启用 审核通过是如果为启用，新增正式表数据生效日期改为下一天
                            newStageBizTmp.setBizOpr("E");
                            totalBizTmpList.add(newStageBizTmp);
                        }
                    } else {
                        //修改临时表的数据
                        BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                        BizTmp tmpStage = bizTmpMapper.selectBizTmpByRealId(instId, mchntStageInfoBean.getId());
                        if (null != tmpStage) {
                            String json = InitParamUtil.getJsonString(tmpStage);
                            MchntStageInfo tmpStageInfo = JSON.parseObject(json, MchntStageInfo.class);
                            MchntStageInfo newStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, tmpStageInfo, mchntStageInfoBean, auditStatus, createTime);
                            //新数据改为启用 审核通过是如果为启用，新增正式表数据生效日期改为下一天
                            tmpStage.setBizOpr("E");
                            tmpStage.setLastOprId(request.getUserId());
                            tmpStage.setLastUpdateTime(createTime);
                            InitParamUtil.initBizTempData(tmpStage, JSONObject.toJSONString(newStageInfo));
                            totalBizTmpList.add(tmpStage);
                        }
                    }
                } else if (DELETE_OPR.equals(mchntStageInfoBean.getOprType())) {
                    //删除 则停用当前的分期数据
                    MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                    if (null != dbStageInfo) {
                        dbStageInfo.setAuditStatus(auditStatus);
                        dbStageInfo.setLastUpdateTime(createTime);
                        dbStageInfo.setLastOprId(request.getUserId());
                        totalStageInfoList.add(dbStageInfo);

                        //临时表 中的正式数据改为失效 失效日期为明天
                        MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                        BeanUtil.beanCopy(dbStageInfo, afterDbMchntStageInfo);
                        afterDbMchntStageInfo.setRecordStatus(AppParamConstant.NO);
                        afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                        BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                        dbStageBizTmp.setBizOpr("D");
                        totalBizTmpList.add(dbStageBizTmp);
                    }
                }
            }
        }


        //交易权限管理
        List<MchntAuthCtrlInfoBean> facadeMchntAuthCtrlInfoList = baseProdBean.getMchntAuthCtrlInfoBeanList();
        if (!CollectionUtils.isEmpty(facadeMchntAuthCtrlInfoList)) {
            MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
            BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
            List<BizTmp> authBizTmpList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_AUTH_CTRL);
            List<MchntAuthCtrl> bizMchntAuthCtrlList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(authBizTmpList)) {
                bizMchntAuthCtrlList = authBizTmpList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntAuthCtrl.class)).collect(Collectors.toList());
            }
            for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeMchntAuthCtrlInfoList) {
                if (ADD_OPR.equals(mchntAuthCtrlInfoBean.getOprType())) {
                    //考虑原有数据是失效， 当前则为重启，则使用原有数据 （产品/权限）
                    MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());
                    if (null == oldMchntAuthCtrl) {
                        //判断临时表是否有记录(修改后第一次新增保存后，没有提交审核，第二次再次新增该权限) 若有记录，则使用原数据，无数据则新增数据
                        boolean exist = false;
                        if (!CollectionUtils.isEmpty(bizMchntAuthCtrlList)) {
                            List<MchntAuthCtrl> targetAuthList = bizMchntAuthCtrlList.stream().filter(item -> mchntAuthCtrlInfoBean.getTxnNum().equals(item.getTxnNum())
                                    && mchntAuthCtrlInfoBean.getBizType().equals(item.getBizType())
                                    && baseProdBean.getBaseProdCode().equals(item.getBizProdCode())).collect(Collectors.toList());
                            if (!CollectionUtils.isEmpty(targetAuthList)) {
                                MchntAuthCtrl target = targetAuthList.get(0);
                                target.setSupportFlag(BompAppParamConstant.FLAG_Y);
                                BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, target.getId(), JSONObject.toJSONString(target),
                                        TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizMchntAuthCtrl);
                                exist = true;
                            }
                        }

                        if (!exist) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        }
                    } else {
                        //将原有失效数据还未修改待审核
                        oldMchntAuthCtrl.setAuditStatus(auditStatus);
                        oldMchntAuthCtrl.setLastOprId(request.getUserId());
                        oldMchntAuthCtrl.setLastUpdateTime(createTime);
                        totalAuthCtrlList.add(oldMchntAuthCtrl);

                        //设置临时表为生效
                        MchntAuthCtrl afterAuthCtrl = new MchntAuthCtrl();
                        BeanUtil.beanCopy(oldMchntAuthCtrl, afterAuthCtrl);
                        afterAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                        BizTmp bizTmpAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, afterAuthCtrl.getId(), JSONObject.toJSONString(afterAuthCtrl),
                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(bizTmpAuthInfo);
                    }
                } else if (MODIFY_OPR.equals(mchntAuthCtrlInfoBean.getOprType())) {
                    //删除 不使用id 查询 有特殊隐藏权限无id，需要用唯一索引查询
                    MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());

                    if (null != oldMchntAuthCtrl) {
                        //正式表数据 审核状态修改
                        oldMchntAuthCtrl.setAuditStatus(auditStatus);
                        oldMchntAuthCtrl.setLastUpdateTime(createTime);
                        oldMchntAuthCtrl.setLastOprId(request.getUserId());
                        totalAuthCtrlList.add(oldMchntAuthCtrl);

                        //临时表 中的正式数据修改
                        MchntAuthCtrl afterDbMchntAuthInfo = new MchntAuthCtrl();
                        BeanUtil.beanCopy(oldMchntAuthCtrl, afterDbMchntAuthInfo);
                        afterDbMchntAuthInfo = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                        BizTmp authBizTmp = initBizTmpByCreate(dbMchntBaseInfo, oldMchntAuthCtrl.getId(), JSONObject.toJSONString(afterDbMchntAuthInfo),
                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(authBizTmp);
                    } else {
                        //原来没有数据则新增临时表
                        MchntAuthCtrl newMchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                        BizTmp authBizTmp = initBizTmpByCreate(dbMchntBaseInfo, newMchntAuthCtrl.getId(), JSONObject.toJSONString(newMchntAuthCtrl),
                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(authBizTmp);
                    }
                } else if (DELETE_OPR.equals(mchntAuthCtrlInfoBean.getOprType())) {
                    //删除 不使用id 查询 有特殊隐藏权限无id，需要用唯一索引查询
                    MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());
                    if (null != oldMchntAuthCtrl) {
                        //正式表数据 审核状态修改
                        oldMchntAuthCtrl.setAuditStatus(auditStatus);
                        oldMchntAuthCtrl.setLastUpdateTime(createTime);
                        oldMchntAuthCtrl.setLastOprId(request.getUserId());
                        totalAuthCtrlList.add(oldMchntAuthCtrl);

                        //临时表 中的正式数据修改
                        MchntAuthCtrl afterDbMchntAuthInfo = new MchntAuthCtrl();
                        BeanUtil.beanCopy(oldMchntAuthCtrl, afterDbMchntAuthInfo);
                        afterDbMchntAuthInfo = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                        afterDbMchntAuthInfo.setSupportFlag(BompAppParamConstant.FLAG_N);
                        BizTmp authBizTmp = initBizTmpByCreate(dbMchntBaseInfo, oldMchntAuthCtrl.getId(), JSONObject.toJSONString(afterDbMchntAuthInfo),
                                TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                        totalBizTmpList.add(authBizTmp);
                    } else {
                        //场景：新增权限保存后，再次取消该权限（内管）
                        rglog.debug("删除产品权限临时表数据");
                        //删除临时表中的数据 不使用id 查询 有特殊隐藏权限无id，需要用唯一索引查询
                        if (!CollectionUtils.isEmpty(bizMchntAuthCtrlList)) {
                            List<MchntAuthCtrl> targetAuthList = bizMchntAuthCtrlList.stream().filter(item -> mchntAuthCtrlInfoBean.getTxnNum().equals(item.getTxnNum())
                                    && mchntAuthCtrlInfoBean.getBizType().equals(item.getBizType())
                                    && baseProdBean.getBaseProdCode().equals(item.getBizProdCode())).collect(Collectors.toList());

                            if (!CollectionUtils.isEmpty(targetAuthList)) {
                                MchntAuthCtrl target = targetAuthList.get(0);
                                target.setSupportFlag(BompAppParamConstant.FLAG_N);
                                BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, target.getId(), JSONObject.toJSONString(target),
                                        TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                                totalBizTmpList.add(bizMchntAuthCtrl);
                            } else {
                                rglog.error("删除产品权限临时表数据不存在！txnNum:{},baseProdCode:{},bizType：{}，id:{}", mchntAuthCtrlInfoBean.getTxnNum(), baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean.getBizType(), mchntAuthCtrlInfoBean.getId());
                            }
                        } else {
                            rglog.error("删除产品权限临时表数据不存在！txnNum:{},baseProdCode:{},bizType：{}，id：{}", mchntAuthCtrlInfoBean.getTxnNum(), baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean.getBizType(), mchntAuthCtrlInfoBean.getId());
                        }
                    }
                }
            }
        }
    }


    @Override
    public void deleteBaseProdInfo(MchntProdInfoManageRequest request, MchntBaseInfo dbMchntBaseInfo, String auditStatus, String createTime, List<MchntProdInfo> totalMchntProdInfoList, List<MchntFeeInfo> totalFeeInfoList, List<MchntStageInfo> totalStageInfoList, List<MchntAuthCtrl> totalAuthCtrlList, List<BizTmp> totalBizTmpList, BaseProdBean baseProdBean) throws Exception {
        String instId = dbMchntBaseInfo.getInstId();
        //修改产品信息
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        //删除该产品 则将产品，分期，费率，权限均设置为失效
        MchntProdInfo oldMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());

        if (null != oldMchntProdInfo) {
            //将原来失效的数据设置为 修改待审核
            oldMchntProdInfo.setAuditStatus(auditStatus);
            oldMchntProdInfo.setLastOprId(request.getUserId());
            oldMchntProdInfo.setLastUpdateTime(createTime);
            totalMchntProdInfoList.add(oldMchntProdInfo);

            //设置临时表为生效
            MchntProdInfo afterProdInfo = new MchntProdInfo();
            BeanUtil.beanCopy(oldMchntProdInfo, afterProdInfo);
            //改为不可用
            afterProdInfo.setRecordStatus(BompAppParamConstant.FLAG_N);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, afterProdInfo.getId(), JSONObject.toJSONString(afterProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);


            //费率数据改为失效
            MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
            List<MchntFeeInfo> dbFeeInfoList = mchntFeeInfoMapper.selectMchntFeeInfoByBaseProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());
            if (!CollectionUtils.isEmpty(dbFeeInfoList)) {
                for (MchntFeeInfo mchntFeeInfo : dbFeeInfoList) {
                    mchntFeeInfo.setAuditStatus(auditStatus);
                    mchntFeeInfo.setLastUpdateTime(createTime);
                    mchntFeeInfo.setLastOprId(request.getUserId());
                    totalFeeInfoList.add(mchntFeeInfo);

                    //临时表 中的正式数据改为失效 失效日期为明天
                    MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                    BeanUtil.beanCopy(mchntFeeInfo, afterDbMchntFeeInfo);
                    afterDbMchntFeeInfo.setRecordStatus(AppParamConstant.NO);
                    afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                    BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                    dbFeeBizTmp.setBizOpr("D");
                    totalBizTmpList.add(dbFeeBizTmp);
                }
            }


            //分期改为失效
            MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
            List<MchntStageInfo> dbStageInfoList = mchntStageInfoMapper.selectMchntStageInfoByBaseProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode(), null);
            if (!CollectionUtils.isEmpty(dbStageInfoList)) {
                for (MchntStageInfo mchntStageInfo : dbStageInfoList) {
                    //删除 则停用当前的分期数据
                    mchntStageInfo.setAuditStatus(auditStatus);
                    mchntStageInfo.setLastUpdateTime(createTime);
                    mchntStageInfo.setLastOprId(request.getUserId());
                    totalStageInfoList.add(mchntStageInfo);

                    //临时表 中的正式数据改为失效 失效日期为明天
                    MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                    BeanUtil.beanCopy(mchntStageInfo, afterDbMchntStageInfo);
                    afterDbMchntStageInfo.setRecordStatus(AppParamConstant.NO);
                    afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                    BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                    dbStageBizTmp.setBizOpr("D");
                    totalBizTmpList.add(dbStageBizTmp);
                }
            }

            //业务权限改为失效
            MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
            List<MchntAuthCtrl> mchntAuthCtrlList = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByBizProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());
            if (!CollectionUtils.isEmpty(mchntAuthCtrlList)) {
                for (MchntAuthCtrl mchntAuthCtrl : mchntAuthCtrlList) {
                    //正式表数据 审核状态修改
                    mchntAuthCtrl.setAuditStatus(auditStatus);
                    mchntAuthCtrl.setLastUpdateTime(createTime);
                    mchntAuthCtrl.setLastOprId(request.getUserId());
                    totalAuthCtrlList.add(mchntAuthCtrl);

                    //临时表 中的正式数据修改
                    MchntAuthCtrl afterDbMchntAuthInfo = new MchntAuthCtrl();
                    BeanUtil.beanCopy(mchntAuthCtrl, afterDbMchntAuthInfo);
                    afterDbMchntAuthInfo.setSupportFlag(BompAppParamConstant.FLAG_N);
                    BizTmp authBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntAuthInfo.getId(), JSONObject.toJSONString(afterDbMchntAuthInfo),
                            TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(authBizTmp);
                }
            }
        }
    }


    @Override
    public void addBaseProdInfoSingleSaveByAuditIsBeOrReject(MchntProdInfoManageRequest request, MchntBaseInfo dbMchntBaseInfo,
                                                             String auditStatus, String createTime,
                                                             List<MchntProdInfo> totalMchntProdInfoList,
                                                             List<MchntFeeInfo> totalFeeInfoList,
                                                             List<MchntStageInfo> totalStageInfoList,
                                                             List<MchntAuthCtrl> totalAuthCtrlList,
                                                             List<BizTmp> totalBizTmpList, BaseProdBean baseProdBean) throws Exception {
        //使用场景：新增拒绝或处于新增草稿的修改单个产品信息（新增/修改/删除）
        //  新增拒绝/新增草稿  -》  修改
        //新增时：插入临时表，正式表   更新时：更新正式表状态，更新/插入临时表   删除：更新正式表审核状态，更新临时表
        rglog.debug("新增产品信息：{}", baseProdBean.getBaseProdCode());
        String instId = dbMchntBaseInfo.getInstId();
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        MchntProdInfo oldMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId,
                dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());

        if (null == oldMchntProdInfo) {
            //新增新的产品前先查询临时表是否有数据
            BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
            List<BizTmp> bizTmpProdList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_PROD_INFO);

            List<MchntProdInfo> prodInfoList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(bizTmpProdList)) {
                prodInfoList = bizTmpProdList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntProdInfo.class)).collect(Collectors.toList());
            }
            //场景：临时表保存了数据，但正式表没有
            Optional<MchntProdInfo> matchOptional = prodInfoList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).findFirst();
            if (matchOptional.isPresent()) {
                //TODO 特殊场景  以前保存到临时表，但是没有提交审批的数据  （点击了单个产品保存，但提交审批时没有选择该产品）
                MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, matchOptional.get(), auditStatus, createTime);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(),
                        JSONObject.toJSONString(mchntProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);

                //TODO 其余数据都需先查临时表
                rglog.debug("=======特殊场景 暂不考虑 以前保存到临时表，但是没有提交审批的数据========");

            } else {
                //Step1.正式表与临时表均没有产品数据（则也不存在费率/业务权限/分期数据），则直接新增到临时表中
                MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreate(request, baseProdBean, auditStatus, createTime);
                totalMchntProdInfoList.add(mchntProdInfo);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(), JSONObject.toJSONString(mchntProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);


                //Step2.费率信息  新增临时表费率信息  (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效，主键不会冲突)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {


                    List<MchntFeeInfo> mchntFeeInfoList = new ArrayList<>();
                    for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                        MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                        mchntFeeInfoList.add(mchntFeeInfo);
                    }
                    totalFeeInfoList.addAll(mchntFeeInfoList);
                    //费率业务临时信息
                    List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                            .map(item ->
                                    initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                            .collect(Collectors.toList());
                    totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
                }

                //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                    List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                        for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            totalAuthCtrlList.add(mchntAuthCtrl);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        }
                    }
                }

                //Step4.分期  新增临时表分期信息 (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                    List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                        List<MchntStageInfo> mchntStageInfoList = facadeStageInfoList.stream()
                                .map(item -> InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                .collect(Collectors.toList());
                        totalStageInfoList.addAll(mchntStageInfoList);
                        //分期临时信息
                        List<BizTmp> mchntStageBizTmp = mchntStageInfoList.stream()
                                .map(item ->
                                        initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                .collect(Collectors.toList());
                        totalBizTmpList.addAll(mchntStageBizTmp);
                    }
                }

            }
        } else {

            rglog.debug("特殊场景，未新增审核通过的数据，再次进行新增【取消某个产品审核拒绝后，再次进产品页面进行保存】/修改");
            //Step1. 将原来数据设置为 新增草稿
            oldMchntProdInfo.setAuditStatus(auditStatus);
            oldMchntProdInfo.setLastOprId(request.getUserId());
            oldMchntProdInfo.setLastUpdateTime(createTime);

            //设置临时表为生效
            MchntProdInfo afterProdInfo = new MchntProdInfo();
            BeanUtil.beanCopy(oldMchntProdInfo, afterProdInfo);
            afterProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, oldMchntProdInfo, auditStatus, createTime);
            //直接修改正式表数据
            totalMchntProdInfoList.add(afterProdInfo);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, afterProdInfo.getId(), JSONObject.toJSONString(afterProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);


            //Step2.费率信息
            List<MchntFeeInfoBean> facadeFeeInfoList = baseProdBean.getMchntFeeInfoBeanList();
            //费率信息 将上传的信息进行修改
            if (!CollectionUtils.isEmpty(facadeFeeInfoList)) {
                MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
                for (MchntFeeInfoBean mchntFeeInfoBean : facadeFeeInfoList) {
                    if (ADD_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //先查数据
                        List<MchntFeeInfo> dbFeeInfoList = mchntFeeInfoMapper.selectMchntFeeInfoByFeeType(instId, dbMchntBaseInfo.getMchntNo(), mchntFeeInfoBean.getBaseProdCode(), mchntFeeInfoBean.getFeeType());
                        if (CollectionUtils.isEmpty(dbFeeInfoList)) {
                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        } else {
                            MchntFeeInfo dbFeeInfo = null;
                            if (dbFeeInfoList.size() > 1) {
                                rglog.error("特殊场景，未新增审核通过的数据，存在两条费率类型一样的数据！");
                                throw new BizException(RespCodeEnum.ILLEGAL_OPERATION.getRespCode(), RespCodeEnum.ILLEGAL_OPERATION.getRespDesc());
                            } else {
                                dbFeeInfo = dbFeeInfoList.get(0);
                            }

                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, dbFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (MODIFY_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //修改时，先查正式表数据，后修改临时表数据，新增新费率的临时表数据
                        MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                        if (null != dbMchntFeeInfo) {
                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, dbMchntFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (DELETE_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //删除
                        MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                        if (null != dbMchntFeeInfo) {
                            dbMchntFeeInfo.setAuditStatus(auditStatus);
                            dbMchntFeeInfo.setLastUpdateTime(createTime);
                            dbMchntFeeInfo.setLastOprId(request.getUserId());

                            //临时表改为失效
                            MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                            BeanUtil.beanCopy(dbMchntFeeInfo, afterDbMchntFeeInfo);
                            //将数据库中的费率设置为失效，失效日期为当天
                            afterDbMchntFeeInfo.setRecordStatus(AppParamConstant.NO);
                            afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            totalFeeInfoList.add(afterDbMchntFeeInfo);
                            BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(dbFeeBizTmp);
                        }
                    }
                }
            }


            //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
            if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                    //判断是否原来就有数据
                    MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                    for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                        //考虑原有数据是失效， 当前则为重启，则使用原有数据 （产品/权限）
                        MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());
                        if (null == oldMchntAuthCtrl) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            totalAuthCtrlList.add(mchntAuthCtrl);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        } else {
                            //将原有失效数据还未修改待审核
                            oldMchntAuthCtrl.setAuditStatus(auditStatus);
                            oldMchntAuthCtrl.setLastOprId(request.getUserId());
                            oldMchntAuthCtrl.setLastUpdateTime(createTime);

                            //设置临时表为生效
                            MchntAuthCtrl afterAuthCtrl = new MchntAuthCtrl();
                            BeanUtil.beanCopy(oldMchntAuthCtrl, afterAuthCtrl);
                            afterAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                            totalAuthCtrlList.add(afterAuthCtrl);
                            BizTmp bizTmpAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, afterAuthCtrl.getId(), JSONObject.toJSONString(afterAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmpAuthInfo);
                        }
                    }
                }
            }

            //Step4.分期  新增临时表分期信息
            List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
            if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
                for (MchntStageInfoBean mchntStageInfoBean : facadeStageInfoList) {
                    if (ADD_OPR.equals(mchntStageInfoBean.getOprType())) {
                        //先查数据
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoByPrimaryKey(instId, dbMchntBaseInfo.getMchntNo(), mchntStageInfoBean.getBaseProdCode(), mchntStageInfoBean.getProdStageCode(), mchntStageInfoBean.getMchntStageNum());
                        if (null == dbStageInfo) {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        } else {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, dbStageInfo, mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }

                    } else if (MODIFY_OPR.equals(mchntStageInfoBean.getOprType())) {
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                        if (null != dbStageInfo) {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, dbStageInfo, mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (DELETE_OPR.equals(mchntStageInfoBean.getOprType())) {
                        //删除 则停用当前的分期数据
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                        if (null != dbStageInfo) {
                            dbStageInfo.setAuditStatus(auditStatus);
                            dbStageInfo.setLastUpdateTime(createTime);
                            dbStageInfo.setLastOprId(request.getUserId());

                            //临时表 中的正式数据改为失效 失效日期为明天
                            MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                            BeanUtil.beanCopy(dbStageInfo, afterDbMchntStageInfo);
                            afterDbMchntStageInfo.setRecordStatus(AppParamConstant.NO);
                            afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            totalStageInfoList.add(afterDbMchntStageInfo);
                            BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                            dbStageBizTmp.setBizOpr("D");
                            totalBizTmpList.add(dbStageBizTmp);
                        }
                    }
                }
            }
        }
    }


    @Override
    public void modifyBaseProdInfoSingleSaveByAuditBeOrReject(MchntProdInfoManageRequest request, MchntBaseInfo dbMchntBaseInfo, String auditStatus,
                                                              String createTime, List<MchntProdInfo> totalMchntProdInfoList, List<MchntFeeInfo> totalFeeInfoList,
                                                              List<MchntStageInfo> totalStageInfoList, List<MchntAuthCtrl> totalAuthCtrlList, List<BizTmp> totalBizTmpList, BaseProdBean baseProdBean) throws Exception {
        //使用场景：新增拒绝或处于新增草稿的修改单个产品信息（新增/修改/删除）
        //  新增拒绝/新增草稿  -》  修改
        //新增时：插入临时表，正式表   更新时：更新正式表状态，更新/插入临时表   删除：更新正式表审核状态，更新临时表
        rglog.debug("新增产品信息：{}", baseProdBean.getBaseProdCode());
        String instId = dbMchntBaseInfo.getInstId();
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        MchntProdInfo oldMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId,
                dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());

        if (null == oldMchntProdInfo) {
            rglog.error("特殊场景，暂时不考虑。【修改-产品数据，但产品正式表里无数据】");
            //新增新的产品前先查询临时表是否有数据
            BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
            List<BizTmp> bizTmpProdList = bizTmpMapper.selectBizTmpByMchntNo(instId, dbMchntBaseInfo.getMchntNo(), TableNameConstant.T_B_MCHNT_PROD_INFO);

            List<MchntProdInfo> prodInfoList = new ArrayList<>();
            if (!CollectionUtils.isEmpty(bizTmpProdList)) {
                prodInfoList = bizTmpProdList.stream().map(item -> JSON.parseObject(InitParamUtil.getJsonString(item), MchntProdInfo.class)).collect(Collectors.toList());
            }
            //场景：临时表保存了数据，但正式表没有
            Optional<MchntProdInfo> matchOptional = prodInfoList.stream().filter(item -> baseProdBean.getBaseProdCode().equals(item.getBaseProdCode())).findFirst();
            if (matchOptional.isPresent()) {
                //TODO 特殊场景  以前保存到临时表，但是没有提交审批的数据  （点击了单个产品保存，但提交审批时没有选择该产品）
                MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, matchOptional.get(), auditStatus, createTime);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(),
                        JSONObject.toJSONString(mchntProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);

                //TODO 其余数据都需先查临时表
                rglog.debug("=======特殊场景 暂不考虑 以前保存到临时表，但是没有提交审批的数据========");

            } else {
                //Step1.正式表与临时表均没有产品数据（则也不存在费率/业务权限/分期数据），则直接新增到临时表中
                MchntProdInfo mchntProdInfo = InitParamUtil.initMchntProdInfoByCreate(request, baseProdBean, auditStatus, createTime);
                totalMchntProdInfoList.add(mchntProdInfo);
                BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, mchntProdInfo.getId(), JSONObject.toJSONString(mchntProdInfo),
                        TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                        BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                totalBizTmpList.add(bizTmpProdInfo);


                //Step2.费率信息  新增临时表费率信息  (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效，主键不会冲突)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntFeeInfoBeanList())) {

                    List<MchntFeeInfo> mchntFeeInfoList = new ArrayList<>();
                    for (MchntFeeInfoBean mchntFeeInfoBean : baseProdBean.getMchntFeeInfoBeanList()) {
                        MchntFeeInfo mchntFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                        mchntFeeInfoList.add(mchntFeeInfo);
                    }
                    totalFeeInfoList.addAll(mchntFeeInfoList);
                    //费率业务临时信息
                    List<BizTmp> mchntFeeInfoBizTmpList = mchntFeeInfoList.stream()
                            .map(item ->
                                    initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                            .collect(Collectors.toList());
                    totalBizTmpList.addAll(mchntFeeInfoBizTmpList);
                }

                //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                    List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                        for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            totalAuthCtrlList.add(mchntAuthCtrl);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        }
                    }
                }

                //Step4.分期  新增临时表分期信息 (不需要关心正式表是否存在失效数据，因为失效审核通过后，失效日期为审核当天，且状态为失效)
                if (!CollectionUtils.isEmpty(baseProdBean.getMchntStageInfoBeanList())) {
                    List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
                    if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                        List<MchntStageInfo> mchntStageInfoList = facadeStageInfoList.stream()
                                .map(item -> InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), item, auditStatus, createTime))
                                .collect(Collectors.toList());
                        totalStageInfoList.addAll(mchntStageInfoList);
                        //分期临时信息
                        List<BizTmp> mchntStageBizTmp = mchntStageInfoList.stream()
                                .map(item ->
                                        initBizTmpByCreate(dbMchntBaseInfo, item.getId(), JSONObject.toJSONString(item),
                                                TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                                BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N))
                                .collect(Collectors.toList());
                        totalBizTmpList.addAll(mchntStageBizTmp);
                    }
                }

            }
        } else {
            //Step1. 将原来数据设置为 新增草稿
            oldMchntProdInfo.setAuditStatus(auditStatus);
            oldMchntProdInfo.setLastOprId(request.getUserId());
            oldMchntProdInfo.setLastUpdateTime(createTime);

            //设置临时表为生效
            MchntProdInfo afterProdInfo = new MchntProdInfo();
            BeanUtil.beanCopy(oldMchntProdInfo, afterProdInfo);
            afterProdInfo = InitParamUtil.initMchntProdInfoByCreateModify(request, baseProdBean, oldMchntProdInfo, auditStatus, createTime);
            //直接修改正式表数据
            totalMchntProdInfoList.add(afterProdInfo);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, afterProdInfo.getId(), JSONObject.toJSONString(afterProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);


            //Step2.费率信息
            List<MchntFeeInfoBean> facadeFeeInfoList = baseProdBean.getMchntFeeInfoBeanList();
            //费率信息 将上传的信息进行修改
            if (!CollectionUtils.isEmpty(facadeFeeInfoList)) {
                MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
                for (MchntFeeInfoBean mchntFeeInfoBean : facadeFeeInfoList) {
                    if (ADD_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //先查数据
                        MchntFeeInfo dbFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoByCondition(instId, dbMchntBaseInfo.getMchntNo(), mchntFeeInfoBean.getBaseProdCode(), mchntFeeInfoBean.getFeeType(), mchntFeeInfoBean.getFeeEffectiveDate());
                        if (null == dbFeeInfo) {
                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        } else {
                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, dbFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (MODIFY_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //修改时，先查正式表数据，后修改临时表数据，新增新费率的临时表数据
                        MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                        if (null != dbMchntFeeInfo) {
                            MchntFeeInfo addFeeInfo = InitParamUtil.initMchntFeeInfoByCreateModify(request, dbMchntFeeInfo, mchntFeeInfoBean, auditStatus, createTime);
                            totalFeeInfoList.add(addFeeInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addFeeInfo.getId(), JSONObject.toJSONString(addFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (DELETE_OPR.equals(mchntFeeInfoBean.getOprType())) {
                        //删除
                        MchntFeeInfo dbMchntFeeInfo = mchntFeeInfoMapper.selectMchntFeeInfoById(instId, mchntFeeInfoBean.getId());
                        if (null != dbMchntFeeInfo) {
                            dbMchntFeeInfo.setAuditStatus(auditStatus);
                            dbMchntFeeInfo.setLastUpdateTime(createTime);
                            dbMchntFeeInfo.setLastOprId(request.getUserId());

                            //临时表改为失效
                            MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                            BeanUtil.beanCopy(dbMchntFeeInfo, afterDbMchntFeeInfo);
                            //将数据库中的费率设置为失效，失效日期为当天
                            afterDbMchntFeeInfo.setRecordStatus(AppParamConstant.NO);
                            afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            totalFeeInfoList.add(afterDbMchntFeeInfo);
                            BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                                    TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(dbFeeBizTmp);
                        }
                    }
                }
            }


            //Step3.业务权限 新增临时表业务权限信息  需要考虑原有数据是失效， 当前则为重启，则使用原有数据因为主键会冲突 （产品/权限）
            if (!CollectionUtils.isEmpty(baseProdBean.getMchntAuthCtrlInfoBeanList())) {
                List<MchntAuthCtrlInfoBean> facadeAuthCtrlList = baseProdBean.getMchntAuthCtrlInfoBeanList();
                if (!CollectionUtils.isEmpty(facadeAuthCtrlList)) {
                    //判断是否原来就有数据
                    MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                    for (MchntAuthCtrlInfoBean mchntAuthCtrlInfoBean : facadeAuthCtrlList) {
                        //考虑原有数据是失效， 当前则为重启，则使用原有数据 （产品/权限）
                        MchntAuthCtrl oldMchntAuthCtrl = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByPrimaryKey(instId, "MCHNT", dbMchntBaseInfo.getMchntNo(), "*", mchntAuthCtrlInfoBean.getTxnNum(), mchntAuthCtrlInfoBean.getBizType());
                        if (null == oldMchntAuthCtrl) {
                            MchntAuthCtrl mchntAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreate(request, baseProdBean.getBaseProdCode(), mchntAuthCtrlInfoBean, auditStatus, createTime);
                            if (DELETE_OPR.equals(mchntAuthCtrlInfoBean.getOprType())) {
                                mchntAuthCtrl.setSupportFlag(BompAppParamConstant.FLAG_N);
                            }
                            totalAuthCtrlList.add(mchntAuthCtrl);
                            BizTmp bizMchntAuthCtrl = initBizTmpByCreate(dbMchntBaseInfo, mchntAuthCtrl.getId(), JSONObject.toJSONString(mchntAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizMchntAuthCtrl);
                        } else {
                            //将原有失效数据还未修改待审核
                            oldMchntAuthCtrl.setAuditStatus(auditStatus);
                            oldMchntAuthCtrl.setLastOprId(request.getUserId());
                            oldMchntAuthCtrl.setLastUpdateTime(createTime);

                            //设置临时表为生效
                            MchntAuthCtrl afterAuthCtrl = new MchntAuthCtrl();
                            BeanUtil.beanCopy(oldMchntAuthCtrl, afterAuthCtrl);
                            afterAuthCtrl = InitParamUtil.initMchntAuthCtrlByCreateModify(request, oldMchntAuthCtrl, mchntAuthCtrlInfoBean, auditStatus, createTime);
                            if (DELETE_OPR.equals(mchntAuthCtrlInfoBean.getOprType())) {
                                afterAuthCtrl.setSupportFlag(BompAppParamConstant.FLAG_N);
                            }
                            totalAuthCtrlList.add(afterAuthCtrl);
                            BizTmp bizTmpAuthInfo = initBizTmpByCreate(dbMchntBaseInfo, afterAuthCtrl.getId(), JSONObject.toJSONString(afterAuthCtrl),
                                    TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmpAuthInfo);
                        }
                    }
                }
            }

            //Step4.分期  新增临时表分期信息
            List<MchntStageInfoBean> facadeStageInfoList = baseProdBean.getMchntStageInfoBeanList();
            if (!CollectionUtils.isEmpty(facadeStageInfoList)) {
                MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
                for (MchntStageInfoBean mchntStageInfoBean : facadeStageInfoList) {
                    if (ADD_OPR.equals(mchntStageInfoBean.getOprType())) {
                        //先查数据
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoByPrimaryKey(instId, dbMchntBaseInfo.getMchntNo(), mchntStageInfoBean.getBaseProdCode(), mchntStageInfoBean.getProdStageCode(), mchntStageInfoBean.getMchntStageNum());
                        if (null == dbStageInfo) {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreate(request, baseProdBean.getBaseProdCode(), mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        } else {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, dbStageInfo, mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }

                    } else if (MODIFY_OPR.equals(mchntStageInfoBean.getOprType())) {
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                        if (null != dbStageInfo) {
                            MchntStageInfo addStageInfo = InitParamUtil.initMchntStageInfoByCreateModify(request, dbStageInfo, mchntStageInfoBean, auditStatus, createTime);
                            totalStageInfoList.add(addStageInfo);
                            //费率业务临时信息
                            BizTmp bizTmp = initBizTmpByCreate(dbMchntBaseInfo, addStageInfo.getId(), JSONObject.toJSONString(addStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            totalBizTmpList.add(bizTmp);
                        }
                    } else if (DELETE_OPR.equals(mchntStageInfoBean.getOprType())) {
                        //删除 则停用当前的分期数据
                        MchntStageInfo dbStageInfo = mchntStageInfoMapper.selectMchntStageInfoById(instId, mchntStageInfoBean.getId());
                        if (null != dbStageInfo) {
                            dbStageInfo.setAuditStatus(auditStatus);
                            dbStageInfo.setLastUpdateTime(createTime);
                            dbStageInfo.setLastOprId(request.getUserId());

                            //临时表 中的正式数据改为失效 失效日期为明天
                            MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                            BeanUtil.beanCopy(dbStageInfo, afterDbMchntStageInfo);
                            afterDbMchntStageInfo.setRecordStatus(AppParamConstant.NO);
                            afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                            totalStageInfoList.add(afterDbMchntStageInfo);
                            BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                                    TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                            //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                            dbStageBizTmp.setBizOpr("D");
                            totalBizTmpList.add(dbStageBizTmp);
                        }
                    }
                }
            }
        }
    }


    @Override
    public void deleteBaseProdInfoSingleSaveByAuditBeOrReject(MchntProdInfoManageRequest request, MchntBaseInfo dbMchntBaseInfo, String auditStatus, String createTime, List<MchntProdInfo> totalMchntProdInfoList, List<MchntFeeInfo> totalFeeInfoList, List<MchntStageInfo> totalStageInfoList, List<MchntAuthCtrl> totalAuthCtrlList, List<BizTmp> totalBizTmpList, BaseProdBean baseProdBean) throws Exception {
        rglog.debug("删除产品信息：{}", baseProdBean.getBaseProdCode());
        String instId = dbMchntBaseInfo.getInstId();
        MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
        //删除该产品 则将产品，分期，费率，权限均设置为失效
        MchntProdInfo oldMchntProdInfo = mchntProdInfoMapper.selectMchntProdInfoByPrimaryKey(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());

        if (null != oldMchntProdInfo) {
            //将原来失效的数据设置为 修改待审核
            oldMchntProdInfo.setAuditStatus(auditStatus);
            oldMchntProdInfo.setLastOprId(request.getUserId());
            oldMchntProdInfo.setLastUpdateTime(createTime);
            totalMchntProdInfoList.add(oldMchntProdInfo);

            //设置临时表为生效
            MchntProdInfo afterProdInfo = new MchntProdInfo();
            BeanUtil.beanCopy(oldMchntProdInfo, afterProdInfo);
            //改为不可用
            afterProdInfo.setRecordStatus(BompAppParamConstant.FLAG_N);
            BizTmp bizTmpProdInfo = initBizTmpByCreate(dbMchntBaseInfo, afterProdInfo.getId(), JSONObject.toJSONString(afterProdInfo),
                    TableNameConstant.T_B_MCHNT_PROD_INFO, auditStatus,
                    BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
            totalBizTmpList.add(bizTmpProdInfo);


            //费率数据改为失效
            MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
            List<MchntFeeInfo> dbFeeInfoList = mchntFeeInfoMapper.selectMchntFeeInfoByBaseProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());
            if (!CollectionUtils.isEmpty(dbFeeInfoList)) {
                for (MchntFeeInfo mchntFeeInfo : dbFeeInfoList) {
                    mchntFeeInfo.setAuditStatus(auditStatus);
                    mchntFeeInfo.setLastUpdateTime(createTime);
                    mchntFeeInfo.setLastOprId(request.getUserId());

                    //临时表 中的正式数据改为失效 失效日期为明天
                    MchntFeeInfo afterDbMchntFeeInfo = new MchntFeeInfo();
                    BeanUtil.beanCopy(mchntFeeInfo, afterDbMchntFeeInfo);
                    afterDbMchntFeeInfo.setRecordStatus(AppParamConstant.NO);
                    afterDbMchntFeeInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                    totalFeeInfoList.add(afterDbMchntFeeInfo);
                    BizTmp dbFeeBizTmp = initBizTmpByCreate(dbMchntBaseInfo, mchntFeeInfo.getId(), JSONObject.toJSONString(afterDbMchntFeeInfo),
                            TableNameConstant.T_B_MCHNT_FEE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                    dbFeeBizTmp.setBizOpr("D");
                    totalBizTmpList.add(dbFeeBizTmp);
                }
            }


            //分期改为失效
            MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
            List<MchntStageInfo> dbStageInfoList = mchntStageInfoMapper.selectMchntStageInfoByBaseProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode(), null);
            if (!CollectionUtils.isEmpty(dbStageInfoList)) {
                for (MchntStageInfo mchntStageInfo : dbStageInfoList) {
                    //删除 则停用当前的分期数据
                    mchntStageInfo.setAuditStatus(auditStatus);
                    mchntStageInfo.setLastUpdateTime(createTime);
                    mchntStageInfo.setLastOprId(request.getUserId());

                    //临时表 中的正式数据改为失效 失效日期为明天
                    MchntStageInfo afterDbMchntStageInfo = new MchntStageInfo();
                    BeanUtil.beanCopy(mchntStageInfo, afterDbMchntStageInfo);
                    afterDbMchntStageInfo.setRecordStatus(AppParamConstant.NO);
                    afterDbMchntStageInfo.setFeeExpiryDate(DateUtil.getCurrentDate());
                    totalStageInfoList.add(afterDbMchntStageInfo);
                    BizTmp dbStageBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntStageInfo.getId(), JSONObject.toJSONString(afterDbMchntStageInfo),
                            TableNameConstant.T_B_MCHNT_STAGE_INFO, auditStatus,
                            BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    //源数据改为停用  审核通过是如果为停用，正式表数据失效日期改为当天
                    dbStageBizTmp.setBizOpr("D");
                    totalBizTmpList.add(dbStageBizTmp);
                }
            }

            //业务权限改为失效
            MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
            List<MchntAuthCtrl> mchntAuthCtrlList = mchntAuthCtrlMapper.selectMchntAuthCtrlInfoByBizProdCode(instId, dbMchntBaseInfo.getMchntNo(), baseProdBean.getBaseProdCode());
            if (!CollectionUtils.isEmpty(mchntAuthCtrlList)) {
                for (MchntAuthCtrl mchntAuthCtrl : mchntAuthCtrlList) {
                    //正式表数据 审核状态修改
                    mchntAuthCtrl.setAuditStatus(auditStatus);
                    mchntAuthCtrl.setLastUpdateTime(createTime);
                    mchntAuthCtrl.setLastOprId(request.getUserId());

                    //临时表 中的正式数据修改
                    MchntAuthCtrl afterDbMchntAuthInfo = new MchntAuthCtrl();
                    BeanUtil.beanCopy(mchntAuthCtrl, afterDbMchntAuthInfo);
                    afterDbMchntAuthInfo.setSupportFlag(BompAppParamConstant.FLAG_N);
                    totalAuthCtrlList.add(afterDbMchntAuthInfo);
                    BizTmp authBizTmp = initBizTmpByCreate(dbMchntBaseInfo, afterDbMchntAuthInfo.getId(), JSONObject.toJSONString(afterDbMchntAuthInfo),
                            TableNameConstant.T_B_MCHNT_AUTH_CTRL, auditStatus, BompAppParamConstant.FLAG_N, BompAppParamConstant.FLAG_N);
                    totalBizTmpList.add(authBizTmp);
                }
            }
        }
    }

    private BizTmp initBizTmpByCreate(MchntBaseInfo mchntBaseInfo,
                                      String id,
                                      String jsonString,
                                      String tableName,
                                      String auditStatus,
                                      String masterShowFlag,
                                      String detailFlag) {
        BizTmp bizTmp = new BizTmp();
        try {
            ConvertUtil.convertOutput(bizTmp);
        } catch (Exception e) {
            rglog.error("ConvertUtil异常：{}", e.toString());
        } finally {
            BeanUtil.beanCopy(mchntBaseInfo, bizTmp);
            bizTmp.setManageInstId(mchntBaseInfo.getSignInstId());
            bizTmp.setMchntName(mchntBaseInfo.getMchntName());
            bizTmp.setRealId(id);
            bizTmp.setOprTableEname(tableName);
            //状态非正式
            bizTmp.setBizStatus(BizTmpStatusEnum.NO_NORMAL.getType());
            //新增
            bizTmp.setBizOpr("I");
            bizTmp.setAuditStatus(auditStatus);
            //主记录标识
            bizTmp.setDetailFlag(detailFlag);
            bizTmp.setMasterShowFlag(masterShowFlag);
            bizTmp.setMasterKey(mchntBaseInfo.getId());
            InitParamUtil.initBizTempData(bizTmp, jsonString);
        }
        return bizTmp;
    }


    /**
     * 新增提交待审批 商户信息
     */
    @Override
    public void addMchntProdInfoDb(MchntBaseInfo mchntBaseInfo, List<BizTmp> bizTmpList, List<BizHistory> bizHistoryList, List<MchntProdInfo> mchntProdInfoList, List<MchntFeeInfo> mchntFeeInfoList, List<MchntStageInfo> mchntStageInfoList, List<MchntAuthCtrl> mchntAuthCtrlList, WechatMchntInfo wechatMchntInfo, AlipayMchntInfo alipayMchntInfo, CupsMchntInfo cupsMchntInfo, MchntSignInfo mchntSignInfo, List<MchntAcctInfo> mchntAcctInfoList, List<MchntImageInfo> mchntImageInfoList) throws Exception {
        /* 开启数据库事务 */
        XmlTreeUtil xmlTreeUtil = new XmlTreeUtil();
        String dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(AppConfigConstant.DATABASE_CONF_NODE, AppConfigConstant.MCMP_POOL_NAME);
        String corporation = xmlTreeUtil.getXmlTreeStringValue(AppParamConstant.CORPORATION);
        if (null != corporation && !corporation.isEmpty()) {
            String dbPoolCashNode = corporation.trim() + AppParamConstant.DATABASE_CONF_NODE;
            dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(dbPoolCashNode, AppConfigConstant.MCMP_POOL_NAME);
        }
        DbsUtil dbsUtil = new DbsUtil(dbPoolName);
        dbsUtil.dbsBeginTransaction();

        try {
            MchntBaseInfoMapper mchntBaseInfoMapper = new MchntBaseInfoMapperImpl();
            int dbResult = mchntBaseInfoMapper.updateMchntBaseInfoById(mchntBaseInfo);
            if (dbResult != 0) {
                dbsUtil.dbsEndTransaction(false);
                rglog.error("商户产品管理：更新商户基本信息表失败！id:{},mchnt:{},instId:{}",
                        mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
            }

            MchntSignInfoMapper mchntSignInfoMapper = new MchntSignInfoMapperImpl();
            dbResult = mchntSignInfoMapper.updateMchntSignInfoById(mchntSignInfo);
            if (dbResult != 0) {
                dbsUtil.dbsEndTransaction(false);
                rglog.error("商户产品管理：更新商户签约信息表失败！id:{},mchnt:{},instId:{}",
                        mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
            }

            MchntAcctInfoMapper mchntAcctInfoMapper = new MchntAcctInfoMapperImpl();
            for (MchntAcctInfo mchntAcctInfo : mchntAcctInfoList) {
                dbResult = mchntAcctInfoMapper.updateMchntAcctInfoById(mchntAcctInfo);
                if (dbResult != 0) {
                    dbResult = mchntAcctInfoMapper.insertMchntAcctInfo(mchntAcctInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：更新商户结算信息表失败！id:{},mchnt:{},instId:{}",
                                mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            MchntImageInfoMapper mchntImageInfoMapper = new MchntImageInfoMapperImpl();
            for (MchntImageInfo mchntImageInfo : mchntImageInfoList) {
                dbResult = mchntImageInfoMapper.updateMchntImageInfoById(mchntImageInfo);
                if (dbResult != 0) {
                    dbResult = mchntImageInfoMapper.insertMchntImageInfo(mchntImageInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：更新商户映像信息表失败！id:{},mchnt:{},instId:{}",
                                mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }


            if (null != wechatMchntInfo) {
                WechatMchntInfoMapper wechatMchntInfoMapper = new WechatMchntInfoMapperImpl();
                //先插入后更新
                dbResult = wechatMchntInfoMapper.insertWechatMchntInfo(wechatMchntInfo);
                if (dbResult != 0) {
                    dbResult = wechatMchntInfoMapper.updateWechatMchntInfoById(wechatMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增微信商户信息表失败！id:{},mchnt:{},instId:{}",
                                wechatMchntInfo.getId(), wechatMchntInfo.getMchntNo(), wechatMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            if (null != alipayMchntInfo) {
                AlipayMchntInfoMapper alipayMchntInfoMapper = new AlipayMchntInfoMapperImpl();
                dbResult = alipayMchntInfoMapper.insertAlipayMchntInfo(alipayMchntInfo);
                if (dbResult != 0) {
                    dbResult = alipayMchntInfoMapper.updateAlipayMchntInfoById(alipayMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增支付宝商户信息表失败！id:{},mchnt:{},instId:{}",
                                alipayMchntInfo.getId(), alipayMchntInfo.getMchntNo(), alipayMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            if (null != cupsMchntInfo) {
                CupsMchntInfoMapper cupsMchntInfoMapper = new CupsMchntInfoMapperImpl();
                dbResult = cupsMchntInfoMapper.insertCupsMchntInfo(cupsMchntInfo);
                if (dbResult != 0) {
                    dbResult = cupsMchntInfoMapper.updateCupsMchntInfoById(cupsMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增银联商户信息表失败！id:{},mchnt:{},instId:{}",
                                cupsMchntInfo.getId(), cupsMchntInfo.getMchntNo(), cupsMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }

                }
            }

            if (!CollectionUtils.isEmpty(mchntProdInfoList)) {
                MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
                for (MchntProdInfo mchntProdInfo : mchntProdInfoList) {
                    dbResult = mchntProdInfoMapper.insertMchntProdInfo(mchntProdInfo);
                    if (dbResult != 0) {
                        dbResult = mchntProdInfoMapper.updateMchntProdInfoById(mchntProdInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新商户产品信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntProdInfo.getId(), mchntProdInfo.getMchntNo(), mchntProdInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntFeeInfoList)) {
                MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
                for (MchntFeeInfo mchntFeeInfo : mchntFeeInfoList) {
                    dbResult = mchntFeeInfoMapper.insertMchntFeeInfo(mchntFeeInfo);
                    if (dbResult != 0) {
                        dbResult = mchntFeeInfoMapper.updateMchntFeeInfoById(mchntFeeInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：新增费率信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntFeeInfo.getId(), mchntFeeInfo.getMchntNo(), mchntFeeInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntStageInfoList)) {
                MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
                for (MchntStageInfo mchntStageInfo : mchntStageInfoList) {
                    dbResult = mchntStageInfoMapper.insertMchntStageInfo(mchntStageInfo);
                    if (dbResult != 0) {
                        dbResult = mchntStageInfoMapper.updateMchntStageInfoById(mchntStageInfo);

                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新分期信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntStageInfo.getId(), mchntStageInfo.getMchntNo(), mchntStageInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }

                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntAuthCtrlList)) {
                MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                for (MchntAuthCtrl mchntAuthCtrl : mchntAuthCtrlList) {
                    dbResult = mchntAuthCtrlMapper.inertMchntAuthCtrlInfo(mchntAuthCtrl);
                    if (dbResult != 0) {
                        dbResult = mchntAuthCtrlMapper.updateMchntAuthCtrlInfoById(mchntAuthCtrl);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：新增业务权限信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntAuthCtrl.getId(), mchntAuthCtrl.getMchntNo(), mchntAuthCtrl.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }


            if (!CollectionUtils.isEmpty(bizTmpList)) {
                BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                for (BizTmp bizTmp : bizTmpList) {
                    dbResult = bizTmpMapper.insertBizTmp(bizTmp);
                    if (dbResult != 0) {
                        dbResult = bizTmpMapper.updateBizTmpByRealId(bizTmp);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("新增商户产品信息-业务临时表记录失败！realId:{},manageInstId:{},instId:{}",
                                    bizTmp.getRealId(), bizTmp.getManageInstId(), bizTmp.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(bizHistoryList)) {
                BizHistoryMapper bizHistoryMapper = new BizHistoryMapperImpl();
                String createTime = DateUtil.getCurrentDateTime(InitParamUtil.yyyy_MM_dd_HHmmssSSS);
                for (BizHistory bizHistory : bizHistoryList) {
                    bizHistory.setCreateTime(createTime);
                    dbResult = bizHistoryMapper.insertBompBizHistory(bizHistory);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("新增商户产品信息-业务历史表记录失败！realId:{},manageInstId:{},instId:{}",
                                bizHistory.getRealId(), bizHistory.getManageInstId(), bizHistory.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }


            if (AuditStatusEnum.STOP_AUDIT_SUCCESS.getAuditStatus().equals(mchntBaseInfo.getAuditStatus())
                    || AuditStatusEnum.CANCEL_AUDIT_SUCCESS.getAuditStatus().equals(mchntBaseInfo.getAuditStatus())) {
                QrCodeInfoMapper qrCodeInfoMapper = new QrCodeInfoMapperImpl();
                QrCodeInfo qrCodeInfo = new QrCodeInfo();
                qrCodeInfo.setInstId(mchntBaseInfo.getInstId());
                qrCodeInfo.setMchntNo(mchntBaseInfo.getMchntNo());
                qrCodeInfo.setQrStatus("01");
                qrCodeInfo.setLastUpdateTime(mchntBaseInfo.getLastAuditTime());
                qrCodeInfo.setLastOprId(mchntBaseInfo.getLastAuditId());
                List<QrCodeInfo> qrCodeInfoList = qrCodeInfoMapper.selectQrCodeInfoByMchntNo(qrCodeInfo.getInstId(), qrCodeInfo.getMchntNo());
                if (!CollectionUtils.isEmpty(qrCodeInfoList)) {
                    dbResult = qrCodeInfoMapper.updateQrCodeInfoStatusByMchntNo(qrCodeInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("停用修改二维码状态失败！InstId:{},MchntNo:{}。",
                                mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }

                TermInfo termInfo = new TermInfo();
                termInfo.setInstId(mchntBaseInfo.getInstId());
                termInfo.setMchntNo(mchntBaseInfo.getMchntNo());
                //02-已停用  03-已注销
                String termStatus = AuditStatusEnum.STOP_AUDIT_SUCCESS.getAuditStatus().equals(mchntBaseInfo.getAuditStatus()) ? "02" : "03";
                termInfo.setTermStatus(termStatus);
                termInfo.setAuditStatus(mchntBaseInfo.getAuditStatus());
                termInfo.setLastAuditId(mchntBaseInfo.getLastAuditId());
                termInfo.setLastAuditTime(mchntBaseInfo.getLastAuditTime());

                TermInfoMapper termInfoMapper = new TermInfoMapperImpl();
                List<TermInfo> termInfos = termInfoMapper.selectBompTermInfoByMchntNo(termInfo.getInstId(), termInfo.getMchntNo());
                if (!CollectionUtils.isEmpty(termInfos)) {
                    dbResult = termInfoMapper.updateBompAllTermStatusByMchntNo(termInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("停用/注销终端状态失败！InstId:{},MchntNo:{}。",
                                mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            dbsUtil.dbsEndTransaction(true);
        } catch (Exception e) {
            dbsUtil.dbsEndTransaction(false);
            rglog.error("商户产品管理失败！mchntNo:{}", mchntBaseInfo.getMchntNo());
            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
        }
    }

    @Override
    public void modifyOrAuditMchntInfoDb(MchntProdInfoManageRequest request, MchntBaseInfo mchntBaseInfo, List<BizTmp> bizTmpList, List<BizHistory> bizHistoryList, List<MchntProdInfo> mchntProdInfoList, List<MchntFeeInfo> mchntFeeInfoList, List<MchntStageInfo> mchntStageInfoList, List<MchntAuthCtrl> mchntAuthCtrlList, WechatMchntInfo wechatMchntInfo, AlipayMchntInfo alipayMchntInfo, CupsMchntInfo cupsMchntInfo, MchntSignInfo mchntSignInfo, List<MchntAcctInfo> mchntAcctInfoList, List<MchntImageInfo> mchntImageInfoList) throws Exception {
        List<QrCodeInfo> qrCodeInfoList = new ArrayList<>();
        List<TermInfo> termInfoList = new ArrayList<>();
        List<MchntBindInfo> mchntBindInfoList = new ArrayList<>();
        List<DevBindInfo> devBindInfoList = new ArrayList<>();
        int dbResult;

        if (AuditStatusEnum.CANCEL_AUDIT_SUCCESS.getAuditStatus().equals(mchntBaseInfo.getAuditStatus())) {
            //二维码停用或注销
            QrCodeInfoMapper qrCodeInfoMapper = new QrCodeInfoMapperImpl();
            qrCodeInfoList = qrCodeInfoMapper.selectQrCodeInfoByMchntNo(mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());

            //终端停用或注销
            TermInfoMapper termInfoMapper = new TermInfoMapperImpl();
            termInfoList = termInfoMapper.selectBompTermInfoByMchntNo(mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());

            //绑定关系解绑
            BspsPublicService bspsPublicService = new BspsPublicServiceImpl();
            mchntBindInfoList = bspsPublicService.getMchntBindInfo(mchntBaseInfo.getInstId(), request.getUserId(), mchntBaseInfo.getMchntNo());

            //语音设备解绑
            devBindInfoList = bspsPublicService.getDevBindInfo(mchntBaseInfo.getInstId(), request.getUserId(), mchntBaseInfo.getMchntNo());
        }


        /* 开启数据库事务 */
        XmlTreeUtil xmlTreeUtil = new XmlTreeUtil();
        String dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(AppConfigConstant.DATABASE_CONF_NODE, AppConfigConstant.MCMP_POOL_NAME);
        String corporation = xmlTreeUtil.getXmlTreeStringValue(AppParamConstant.CORPORATION);
        if (null != corporation && !corporation.isEmpty()) {
            String dbPoolCashNode = corporation.trim() + AppParamConstant.DATABASE_CONF_NODE;
            dbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(dbPoolCashNode, AppConfigConstant.MCMP_POOL_NAME);
        }
        DbsUtil dbsUtil = new DbsUtil(dbPoolName);
        dbsUtil.dbsBeginTransaction();

        try {
            MchntBaseInfoMapper mchntBaseInfoMapper = new MchntBaseInfoMapperImpl();
            dbResult = mchntBaseInfoMapper.updateMchntBaseInfoById(mchntBaseInfo);
            if (dbResult != 0) {
                dbsUtil.dbsEndTransaction(false);
                rglog.error("商户产品管理：更新商户基本信息表失败！id:{},mchnt:{},instId:{}",
                        mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
            }

            MchntSignInfoMapper mchntSignInfoMapper = new MchntSignInfoMapperImpl();
            dbResult = mchntSignInfoMapper.updateMchntSignInfoById(mchntSignInfo);
            if (dbResult != 0) {
                dbsUtil.dbsEndTransaction(false);
                rglog.error("商户产品管理：更新商户签约信息表失败！id:{},mchnt:{},instId:{}",
                        mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
            }

            if (!CollectionUtils.isEmpty(mchntAcctInfoList)) {
                MchntAcctInfoMapper mchntAcctInfoMapper = new MchntAcctInfoMapperImpl();
                for (MchntAcctInfo mchntAcctInfo : mchntAcctInfoList) {
                    dbResult = mchntAcctInfoMapper.updateMchntAcctInfoById(mchntAcctInfo);
                    if (dbResult != 0) {
                        dbResult = mchntAcctInfoMapper.insertMchntAcctInfo(mchntAcctInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新商户结算信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntImageInfoList)) {
                MchntImageInfoMapper mchntImageInfoMapper = new MchntImageInfoMapperImpl();
                for (MchntImageInfo mchntImageInfo : mchntImageInfoList) {
                    dbResult = mchntImageInfoMapper.updateMchntImageInfoById(mchntImageInfo);
                    if (dbResult != 0) {
                        dbResult = mchntImageInfoMapper.insertMchntImageInfo(mchntImageInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新商户映像信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntBaseInfo.getId(), mchntBaseInfo.getMchntNo(), mchntBaseInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }


            if (null != wechatMchntInfo) {
                WechatMchntInfoMapper wechatMchntInfoMapper = new WechatMchntInfoMapperImpl();
                //先更新后插入
                dbResult = wechatMchntInfoMapper.updateWechatMchntInfoById(wechatMchntInfo);
                if (dbResult != 0) {
                    dbResult = wechatMchntInfoMapper.insertWechatMchntInfo(wechatMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增微信商户信息表失败！id:{},mchnt:{},instId:{}",
                                wechatMchntInfo.getId(), wechatMchntInfo.getMchntNo(), wechatMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            if (null != alipayMchntInfo) {
                AlipayMchntInfoMapper alipayMchntInfoMapper = new AlipayMchntInfoMapperImpl();
                dbResult = alipayMchntInfoMapper.updateAlipayMchntInfoById(alipayMchntInfo);
                if (dbResult != 0) {
                    dbResult = alipayMchntInfoMapper.insertAlipayMchntInfo(alipayMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增支付宝商户信息表失败！id:{},mchnt:{},instId:{}",
                                alipayMchntInfo.getId(), alipayMchntInfo.getMchntNo(), alipayMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }

            if (null != cupsMchntInfo) {
                CupsMchntInfoMapper cupsMchntInfoMapper = new CupsMchntInfoMapperImpl();
                dbResult = cupsMchntInfoMapper.updateCupsMchntInfoById(cupsMchntInfo);
                if (dbResult != 0) {
                    dbResult = cupsMchntInfoMapper.insertCupsMchntInfo(cupsMchntInfo);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("商户产品管理：新增银联商户信息表失败！id:{},mchnt:{},instId:{}",
                                cupsMchntInfo.getId(), cupsMchntInfo.getMchntNo(), cupsMchntInfo.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }

                }
            }

            if (!CollectionUtils.isEmpty(mchntProdInfoList)) {
                MchntProdInfoMapper mchntProdInfoMapper = new MchntProdInfoMapperImpl();
                for (MchntProdInfo mchntProdInfo : mchntProdInfoList) {
                    dbResult = mchntProdInfoMapper.updateMchntProdInfoById(mchntProdInfo);
                    if (dbResult != 0) {
                        dbResult = mchntProdInfoMapper.insertMchntProdInfo(mchntProdInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新商户产品信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntProdInfo.getId(), mchntProdInfo.getMchntNo(), mchntProdInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntFeeInfoList)) {
                MchntFeeInfoMapper mchntFeeInfoMapper = new MchntFeeInfoMapperImpl();
                for (MchntFeeInfo mchntFeeInfo : mchntFeeInfoList) {
                    dbResult = mchntFeeInfoMapper.updateMchntFeeInfoById(mchntFeeInfo);
                    if (dbResult != 0) {
                        dbResult = mchntFeeInfoMapper.insertMchntFeeInfo(mchntFeeInfo);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：新增费率信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntFeeInfo.getId(), mchntFeeInfo.getMchntNo(), mchntFeeInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntStageInfoList)) {
                MchntStageInfoMapper mchntStageInfoMapper = new MchntStageInfoMapperImpl();
                for (MchntStageInfo mchntStageInfo : mchntStageInfoList) {
                    dbResult = mchntStageInfoMapper.updateMchntStageInfoById(mchntStageInfo);
                    if (dbResult != 0) {
                        dbResult = mchntStageInfoMapper.insertMchntStageInfo(mchntStageInfo);

                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：更新分期信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntStageInfo.getId(), mchntStageInfo.getMchntNo(), mchntStageInfo.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }

                    }
                }
            }

            if (!CollectionUtils.isEmpty(mchntAuthCtrlList)) {
                MchntAuthCtrlMapper mchntAuthCtrlMapper = new MchntAuthCtrlMapperImpl();
                for (MchntAuthCtrl mchntAuthCtrl : mchntAuthCtrlList) {
                    dbResult = mchntAuthCtrlMapper.updateMchntAuthCtrlInfoById(mchntAuthCtrl);
                    if (dbResult != 0) {
                        dbResult = mchntAuthCtrlMapper.inertMchntAuthCtrlInfo(mchntAuthCtrl);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("商户产品管理：新增业务权限信息表失败！id:{},mchnt:{},instId:{}",
                                    mchntAuthCtrl.getId(), mchntAuthCtrl.getMchntNo(), mchntAuthCtrl.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }


            if (!CollectionUtils.isEmpty(bizTmpList)) {
                BizTmpMapper bizTmpMapper = new BizTmpMapperImpl();
                for (BizTmp bizTmp : bizTmpList) {
                    dbResult = bizTmpMapper.updateBizTmpByRealId(bizTmp);
                    if (dbResult != 0) {
                        dbResult = bizTmpMapper.insertBizTmp(bizTmp);
                        if (dbResult != 0) {
                            dbsUtil.dbsEndTransaction(false);
                            rglog.error("新增商户产品信息-业务临时表记录失败！realId:{},manageInstId:{},instId:{}",
                                    bizTmp.getRealId(), bizTmp.getManageInstId(), bizTmp.getInstId());
                            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                        }
                    }
                }
            }

            if (!CollectionUtils.isEmpty(bizHistoryList)) {
                BizHistoryMapper bizHistoryMapper = new BizHistoryMapperImpl();
                String createTime = DateUtil.getCurrentDateTime(InitParamUtil.yyyy_MM_dd_HHmmssSSS);
                for (BizHistory bizHistory : bizHistoryList) {
                    bizHistory.setCreateTime(createTime);
                    dbResult = bizHistoryMapper.insertBompBizHistory(bizHistory);
                    if (dbResult != 0) {
                        dbsUtil.dbsEndTransaction(false);
                        rglog.error("新增商户产品信息-业务历史表记录失败！realId:{},manageInstId:{},instId:{}",
                                bizHistory.getRealId(), bizHistory.getManageInstId(), bizHistory.getInstId());
                        throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                    }
                }
            }


            if (!CollectionUtils.isEmpty(qrCodeInfoList)) {
                QrCodeInfoMapper qrCodeInfoMapper = new QrCodeInfoMapperImpl();
                QrCodeInfo qrCodeInfo = new QrCodeInfo();
                qrCodeInfo.setInstId(mchntBaseInfo.getInstId());
                qrCodeInfo.setMchntNo(mchntBaseInfo.getMchntNo());
                // 00-绑定 01-解绑
                qrCodeInfo.setQrStatus("01");
                qrCodeInfo.setLastUpdateTime(mchntBaseInfo.getLastAuditTime());
                qrCodeInfo.setLastOprId(mchntBaseInfo.getLastAuditId());
                dbResult = qrCodeInfoMapper.updateQrCodeInfoStatusByMchntNo(qrCodeInfo);
                if (dbResult != 0) {
                    dbsUtil.dbsEndTransaction(false);
                    rglog.error("停用修改二维码状态失败！InstId:{},MchntNo:{}。",
                            mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                    throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                }
            }


            if (!CollectionUtils.isEmpty(termInfoList)) {
                //终端停用或注销
                TermInfo termInfo = new TermInfo();
                termInfo.setInstId(mchntBaseInfo.getInstId());
                termInfo.setMchntNo(mchntBaseInfo.getMchntNo());
                //02-已停用  03-已注销
                String termStatus = AuditStatusEnum.STOP_AUDIT_SUCCESS.getAuditStatus().equals(mchntBaseInfo.getAuditStatus()) ? "02" : "03";
                termInfo.setTermStatus(termStatus);
                termInfo.setAuditStatus(mchntBaseInfo.getAuditStatus());
                termInfo.setLastAuditId(mchntBaseInfo.getLastAuditId());
                termInfo.setLastAuditTime(mchntBaseInfo.getLastAuditTime());

                TermInfoMapper termInfoMapper = new TermInfoMapperImpl();
                dbResult = termInfoMapper.updateBompAllTermStatusByMchntNo(termInfo);
                if (dbResult != 0) {
                    dbsUtil.dbsEndTransaction(false);
                    rglog.error("停用/注销终端状态失败！InstId:{},MchntNo:{}。",
                            mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                    throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                }
            }

            dbsUtil.dbsEndTransaction(true);
        } catch (Exception e) {
            dbsUtil.dbsEndTransaction(false);
            rglog.error("商户产品管理失败！mchntNo:{}", mchntBaseInfo.getMchntNo());
            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
        }

        String oltpDbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(AppConfigConstant.DATABASE_CONF_NODE, AppConfigConstant.OLTP_POOL_NAME);
        if (null != corporation && !corporation.isEmpty()) {
            String dbPoolCashNode = corporation.trim() + AppParamConstant.DATABASE_CONF_NODE;
            oltpDbPoolName = XmlConfigUtil.getXmlConfigCacheKeyValue(dbPoolCashNode, AppConfigConstant.OLTP_POOL_NAME);
        }
        DbsUtil oltpDbsUtil = new DbsUtil(oltpDbPoolName);
        oltpDbsUtil.dbsBeginTransaction();
        try {
            //解绑绑定关系
            BspsPublicService bspsPublicService = new BspsPublicServiceImpl();
            if (!CollectionUtils.isEmpty(mchntBindInfoList)) {
                boolean unBindFlag = bspsPublicService.mchntUnBind(mchntBaseInfo.getInstId(), request.getUserId(), mchntBaseInfo.getMchntNo());
                if (!unBindFlag) {
                    oltpDbsUtil.dbsEndTransaction(false);
                    rglog.error("解绑商户绑定关系失败！InstId:{},MchntNo:{}.",
                            mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                    throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                }

            }
            //解绑设备绑定关系
            if (!CollectionUtils.isEmpty(devBindInfoList)) {
                boolean unBindFlag = bspsPublicService.devUnBind(mchntBaseInfo.getInstId(), request.getUserId(), mchntBaseInfo.getMchntNo());
                if (!unBindFlag) {
                    oltpDbsUtil.dbsEndTransaction(false);
                    rglog.error("解绑商户设备绑定关系失败！InstId:{},MchntNo:{}.",
                            mchntBaseInfo.getInstId(), mchntBaseInfo.getMchntNo());
                    throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
                }
            }
            oltpDbsUtil.dbsEndTransaction(true);
        } catch (Exception e) {
            oltpDbsUtil.dbsEndTransaction(false);
            rglog.error("解绑商户<{}>关系失败,{}", mchntBaseInfo.getMchntNo(), e.getMessage());
            throw new BizException(RespCodeEnum.DATABASE_OPR_ERROR.getRespCode(), RespCodeEnum.DATABASE_OPR_ERROR.getRespDesc());
        }
    }
}
